@riverbankcms/sdk 0.88.0 → 0.90.0

package/dist/server/server.mjs

@@ -1865,6 +1865,24 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  resendSiteInvitation: {
+    path: "/sites/{siteId}/members/invitations/{invitationId}/resend",
+    method: "POST",
+    errors: [
+      "auth:forbidden",
+      "resource:not_found",
+      "validation:invalid_input",
+      "external:service_error",
+      "server:internal_error"
+    ],
+    tags: [
+      "site-{siteId}",
+      "site-members-{siteId}",
+      "site-invite-{invitationId}"
+    ],
+    auth: "user",
+    responseKind: "json"
+  },
   transferSiteOwnership: {
     path: "/sites/{siteId}/members/transfer-ownership",
     method: "POST",
@@ -6501,19 +6519,23 @@ function normalizeDashboardOrigin(input) {
 }
 function deriveCmsApiUrlFromDashboardUrl(input) {
   const origin = normalizeDashboardOrigin(input);
-  return origin ? `${origin}/api` : "";
+  return origin ? normalizeCmsApiBaseUrl(`${origin}/api`) : "";
+}
+function normalizeCmsApiBaseUrl(input) {
+  return input.trim().replace(/\/+$/, "").replace(/(?:\/api)+$/i, "/api");
 }
 function getCmsApiUrl() {
   if (typeof window !== "undefined") {
-    return "/api";
+    return normalizeCmsApiBaseUrl("/api");
   }
   const internalUrl = process.env.CMS_API_URL;
   if (internalUrl) {
-    return internalUrl.replace(/\/$/, "");
+    return normalizeCmsApiBaseUrl(internalUrl);
   }
   const dashboardUrl = process.env.NEXT_PUBLIC_DASHBOARD_URL;
   if (dashboardUrl) {
-    return deriveCmsApiUrlFromDashboardUrl(dashboardUrl);
+    const apiUrl = deriveCmsApiUrlFromDashboardUrl(dashboardUrl);
+    if (apiUrl) return apiUrl;
   }
   throw new Error(
     "CMS_API_URL or NEXT_PUBLIC_DASHBOARD_URL is not configured. Set NEXT_PUBLIC_DASHBOARD_URL to your dashboard URL (e.g., http://localhost:4000)"
@@ -6622,6 +6644,27 @@ function serializeQueryValue(value) {
   if (value instanceof Date) return value.toISOString();
   return null;
 }
+function normalizeHeaders(source) {
+  const normalized = {};
+  if (!source) return normalized;
+  new Headers(source).forEach((value, key) => {
+    normalized[key] = value;
+  });
+  return normalized;
+}
+function buildRequestHeaders(input) {
+  const headers = {
+    ...normalizeHeaders(input.optionsHeaders),
+    ...normalizeHeaders(input.authHeaders)
+  };
+  if (input.sdkVersion) {
+    headers["x-sdk-version"] = input.sdkVersion;
+  }
+  if (input.includeJsonContentType) {
+    headers["Content-Type"] = "application/json";
+  }
+  return headers;
+}
 function serializePathParam(endpoint, key, value) {
   if (typeof value === "string") {
     return value;
@@ -6757,104 +6800,20 @@ function createRawCMSClient(headers = {}, baseUrl) {
     params,
     options = {}
   }) => {
-    const resolvedBaseUrl = baseUrl ?? resolveApiBaseUrl();
-    let url = buildEndpointURL(resolvedBaseUrl, endpoint);
-    const originalPath = API_ENDPOINTS[endpoint].path;
-    const unusedParams = {};
-    if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        const bracePlaceholder = `{${key}}`;
-        const colonPlaceholder = `:${key}`;
-        if (originalPath.includes(bracePlaceholder) || originalPath.includes(colonPlaceholder)) {
-          const stringValue = serializePathParam(endpoint, key, value);
-          url = url.replace(bracePlaceholder, stringValue);
-          url = url.replace(colonPlaceholder, stringValue);
-        } else {
-          unusedParams[key] = value;
-        }
-      });
-    }
-    const unresolvedPathParams = [
-      ...url.match(/\{[^}]+\}/g) ?? [],
-      ...url.match(/(^|\/):([A-Za-z][A-Za-z0-9_]*)\b/g) ?? []
-    ];
-    if (unresolvedPathParams.length > 0) {
-      const missingParams = Array.from(
-        new Set(
-          unresolvedPathParams.map((token) => {
-            if (token.startsWith("{") && token.endsWith("}")) {
-              return token.slice(1, -1);
-            }
-            return token.replace(/^\//, "").slice(1);
-          })
-        )
-      );
-      throw new Error(
-        `Missing required path params for endpoint ${String(endpoint)}: ${missingParams.join(", ")}`
-      );
-    }
-    const endpointConfig = API_ENDPOINTS[endpoint];
-    const method = endpointConfig.method;
-    const isGetOrHead = method === "GET" || method === "HEAD";
-    const queryParams = new URLSearchParams();
-    Object.entries(unusedParams).forEach(([key, value]) => {
-      appendQueryParam(queryParams, key, value);
+    const plan = buildApiRequestPlan({
+      endpoint,
+      body,
+      params,
+      options,
+      headers,
+      baseUrl: normalizeCmsApiBaseUrl(baseUrl ?? resolveApiBaseUrl()),
+      sdkVersion
     });
-    if (isGetOrHead && typeof body === "object" && body !== null && !isFormDataBody(body)) {
-      Object.entries(body).forEach(([key, value]) => {
-        appendQueryParam(queryParams, key, value);
-      });
-    }
-    const queryString = queryParams.toString();
-    if (queryString) {
-      url += (url.includes("?") ? "&" : "?") + queryString;
-    }
-    const formDataBody = isFormDataBody(body) ? body : void 0;
-    const optionsNext = options?.next;
-    const nextOptions = { ...optionsNext ?? {} };
-    const cacheIsNoStore = options?.cache === "no-store";
-    if (cacheIsNoStore) {
-      delete nextOptions.revalidate;
-    } else if (isGetOrHead && nextOptions.revalidate === void 0 && "revalidate" in endpointConfig && typeof endpointConfig.revalidate === "number") {
-      nextOptions.revalidate = endpointConfig.revalidate;
-    }
-    if ("tags" in endpointConfig && Array.isArray(endpointConfig.tags)) {
-      const processedTags = endpointConfig.tags.map((tag) => {
-        let processedTag = tag;
-        if (params) {
-          Object.entries(params).forEach(([key, value]) => {
-            processedTag = processedTag.replace(`{${key}}`, String(value));
-          });
-        }
-        return /\{[^}]+\}/.test(processedTag) ? null : processedTag;
-      }).filter((tag) => tag !== null);
-      nextOptions.tags = Array.from(/* @__PURE__ */ new Set([...nextOptions.tags ?? [], ...processedTags]));
-    }
-    const requestInit = {
-      method,
-      ...options,
-      // Include credentials for same-origin requests (sends cookies for auth)
-      credentials: "same-origin",
-      // Don't include body for GET/HEAD requests
-      // FormData is pre-narrowed via isFormDataBody() above
-      body: isGetOrHead || body == null ? void 0 : formDataBody ?? JSON.stringify(body),
-      headers: {
-        ...options.headers,
-        ...headers,
-        // Include SDK version if set
-        ...sdkVersion && { "x-sdk-version": sdkVersion },
-        // Don't set Content-Type for GET/HEAD requests without body
-        ...isGetOrHead ? {} : formDataBody ? {} : { "Content-Type": "application/json" }
-      },
-      // Add Next.js caching options
-      next: Object.keys(nextOptions).length > 0 ? nextOptions : void 0
-    };
-    const fetchPromise = fetch(url, requestInit);
-    if (!isGetOrHead && "tags" in endpointConfig && Array.isArray(endpointConfig.tags)) {
-      const tags2 = endpointConfig.tags.map((tag) => tag);
+    const fetchPromise = fetch(plan.url, plan.init);
+    if (plan.cacheInvalidationTags) {
       return fetchPromise.then((response) => {
         if (response.ok) {
-          invalidateCacheTags(tags2, params);
+          invalidateCacheTags(plan.cacheInvalidationTags, params);
         }
         return response;
       });
@@ -6862,6 +6821,100 @@ function createRawCMSClient(headers = {}, baseUrl) {
     return fetchPromise;
   };
 }
+function buildApiRequestPlan(input) {
+  const { endpoint, body, params, headers = {}, baseUrl } = input;
+  const options = input.options ?? {};
+  let url = buildEndpointURL(baseUrl, endpoint);
+  const originalPath = API_ENDPOINTS[endpoint].path;
+  const unusedParams = {};
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      const bracePlaceholder = `{${key}}`;
+      const colonPlaceholder = `:${key}`;
+      if (originalPath.includes(bracePlaceholder) || originalPath.includes(colonPlaceholder)) {
+        const stringValue = serializePathParam(endpoint, key, value);
+        url = url.replace(bracePlaceholder, stringValue);
+        url = url.replace(colonPlaceholder, stringValue);
+      } else {
+        unusedParams[key] = value;
+      }
+    });
+  }
+  const unresolvedPathParams = [
+    ...url.match(/\{[^}]+\}/g) ?? [],
+    ...url.match(/(^|\/):([A-Za-z][A-Za-z0-9_]*)\b/g) ?? []
+  ];
+  if (unresolvedPathParams.length > 0) {
+    const missingParams = Array.from(
+      new Set(
+        unresolvedPathParams.map((token) => {
+          if (token.startsWith("{") && token.endsWith("}")) {
+            return token.slice(1, -1);
+          }
+          return token.replace(/^\//, "").slice(1);
+        })
+      )
+    );
+    throw new Error(
+      `Missing required path params for endpoint ${String(endpoint)}: ${missingParams.join(", ")}`
+    );
+  }
+  const endpointConfig = API_ENDPOINTS[endpoint];
+  const method = endpointConfig.method;
+  const isGetOrHead = method === "GET" || method === "HEAD";
+  const queryParams = new URLSearchParams();
+  Object.entries(unusedParams).forEach(([key, value]) => {
+    appendQueryParam(queryParams, key, value);
+  });
+  if (isGetOrHead && typeof body === "object" && body !== null && !isFormDataBody(body)) {
+    Object.entries(body).forEach(([key, value]) => {
+      appendQueryParam(queryParams, key, value);
+    });
+  }
+  const queryString = queryParams.toString();
+  if (queryString) {
+    url += (url.includes("?") ? "&" : "?") + queryString;
+  }
+  const formDataBody = isFormDataBody(body) ? body : void 0;
+  const optionsNext = options?.next;
+  const nextOptions = { ...optionsNext ?? {} };
+  const cacheIsNoStore = options?.cache === "no-store";
+  if (cacheIsNoStore) {
+    delete nextOptions.revalidate;
+  } else if (isGetOrHead && nextOptions.revalidate === void 0 && "revalidate" in endpointConfig && typeof endpointConfig.revalidate === "number") {
+    nextOptions.revalidate = endpointConfig.revalidate;
+  }
+  if ("tags" in endpointConfig && Array.isArray(endpointConfig.tags)) {
+    const processedTags = endpointConfig.tags.map((tag) => {
+      let processedTag = tag;
+      if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+          processedTag = processedTag.replace(`{${key}}`, String(value));
+        });
+      }
+      return /\{[^}]+\}/.test(processedTag) ? null : processedTag;
+    }).filter((tag) => tag !== null);
+    nextOptions.tags = Array.from(/* @__PURE__ */ new Set([...nextOptions.tags ?? [], ...processedTags]));
+  }
+  const init = {
+    method,
+    ...options,
+    credentials: "same-origin",
+    body: isGetOrHead || body == null ? void 0 : formDataBody ?? JSON.stringify(body),
+    headers: buildRequestHeaders({
+      optionsHeaders: options.headers,
+      authHeaders: headers,
+      sdkVersion: input.sdkVersion,
+      includeJsonContentType: !isGetOrHead && !formDataBody
+    }),
+    ...Object.keys(nextOptions).length > 0 ? { next: nextOptions } : {}
+  };
+  return {
+    url,
+    init,
+    ...!isGetOrHead && "tags" in endpointConfig && Array.isArray(endpointConfig.tags) ? { cacheInvalidationTags: endpointConfig.tags.map((tag) => tag) } : {}
+  };
+}
 function createParsedClient(rawClient) {
   return async (params) => {
     const response = await rawClient(params);
@@ -7042,7 +7095,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.88.0";
+var SDK_VERSION = "0.90.0";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -7199,6 +7252,476 @@ function attachResilienceStatusToError(error, resilienceStatus) {
   return target;
 }
 
+// src/public-api/runtime.ts
+var PUBLIC_ENDPOINT_NAMES2 = [
+  "getSite",
+  "getContentByPath",
+  "listPublishedEntries",
+  "getPublishedEntryPreview",
+  "getPublicFormById",
+  "listPublicForms",
+  "getPublicBookingServices",
+  "getPublicChallenge",
+  "listPublicEvents",
+  "batchBlockLoaders",
+  "listPublicCourses",
+  "listPublicTeamMembers",
+  "listPublicProducts",
+  "listPublicPasses",
+  "listPublicMemberships",
+  "resolveEntrySubroute",
+  "resolveEventOccurrence",
+  "checkRedirect",
+  "getRoutableContent",
+  "getPublicRoutableContent",
+  "getPublicSitemapRoutes"
+];
+var API_ENDPOINTS2 = Object.freeze({
+  getSite: {
+    path: "/sites",
+    method: "GET",
+    revalidate: 900,
+    tags: ["riverbank:site", "riverbank:site:id:{id}", "riverbank:site:slug:{slug}", "riverbank:site:domain:{domain}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getContentByPath: {
+    path: "/sites/{siteId}/pages",
+    method: "GET",
+    tags: ["riverbank:site:{siteId}:routable-content"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublishedEntries: {
+    path: "/public/content/{siteId}/{type}/entries",
+    method: "GET",
+    revalidate: 60,
+    tags: ["content-{siteId}-{type}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublishedEntryPreview: {
+    path: "/public/content/{siteId}/{type}/{slug}/preview",
+    method: "GET",
+    revalidate: 60,
+    tags: ["content-{siteId}-{type}-{slug}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicFormById: {
+    path: "/public/forms/{formId}",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:form:{formId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicForms: {
+    path: "/public/sites/{siteId}/forms",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:forms"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicBookingServices: {
+    path: "/public/bookings/services",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicChallenge: {
+    path: "/public/challenge",
+    method: "GET",
+    auth: "public",
+    responseKind: "text"
+  },
+  listPublicEvents: {
+    path: "/public/sites/{siteId}/events",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-events"],
+    auth: "public",
+    responseKind: "json"
+  },
+  batchBlockLoaders: {
+    path: "/public/sites/{siteId}/block-loaders/batch",
+    method: "POST",
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicCourses: {
+    path: "/public/sites/{siteId}/courses",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-courses"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicTeamMembers: {
+    path: "/public/sites/{siteId}/team-members",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-team-members"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicProducts: {
+    path: "/public/sites/{siteId}/products",
+    method: "GET",
+    revalidate: 300,
+    tags: ["riverbank:site:{siteId}:public-products"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicPasses: {
+    path: "/public/sites/{siteId}/bookings/products/passes",
+    method: "GET",
+    revalidate: 300,
+    tags: ["riverbank:site:{siteId}:public-passes"],
+    auth: "public",
+    responseKind: "json"
+  },
+  listPublicMemberships: {
+    path: "/public/sites/{siteId}/bookings/products/memberships",
+    method: "GET",
+    revalidate: 300,
+    tags: ["riverbank:site:{siteId}:public-memberships"],
+    auth: "public",
+    responseKind: "json"
+  },
+  resolveEntrySubroute: {
+    path: "/public/sites/{siteId}/routing/subroutes/resolve",
+    method: "GET",
+    revalidate: 60,
+    tags: ["site-{siteId}", "entry-subroute"],
+    auth: "public",
+    responseKind: "json"
+  },
+  resolveEventOccurrence: {
+    path: "/public/sites/{siteId}/events/occurrences/resolve",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:public-events", "event-occurrence"],
+    auth: "public",
+    responseKind: "json"
+  },
+  checkRedirect: {
+    path: "/public/content/redirect",
+    method: "GET",
+    revalidate: 86400,
+    tags: ["redirect"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getRoutableContent: {
+    path: "/sites/{siteId}/routable-content",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:routable-content"],
+    auth: "user",
+    responseKind: "json"
+  },
+  getPublicRoutableContent: {
+    path: "/public/sites/{siteId}/routable-content",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:routable-content"],
+    auth: "public",
+    responseKind: "json"
+  },
+  getPublicSitemapRoutes: {
+    path: "/public/sites/{siteId}/sitemap",
+    method: "GET",
+    revalidate: 60,
+    tags: ["riverbank:site:{siteId}:routable-content", "riverbank:site:{siteId}:settings"],
+    auth: "public",
+    responseKind: "json"
+  }
+});
+
+// src/client/runtimeCachePolicy.ts
+var DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION = 1;
+var DEFAULT_STALE_TTL_SEC = 24 * 60 * 60;
+var DEFAULT_MEMORY_TTL_SEC = 60;
+var RUNTIME_CACHE_DURABILITY_OVERRIDES = {
+  getSite: {
+    kind: "durable-public-stale",
+    staleTtlSec: DEFAULT_STALE_TTL_SEC
+  },
+  getContentByPath: {
+    kind: "durable-public-stale",
+    staleTtlSec: DEFAULT_STALE_TTL_SEC
+  },
+  listPublishedEntries: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublishedEntryPreview: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublicFormById: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicForms: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublicBookingServices: {
+    kind: "live-only",
+    reason: "safety_sensitive_booking"
+  },
+  getPublicChallenge: {
+    kind: "live-only",
+    reason: "challenge_endpoint"
+  },
+  listPublicEvents: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  batchBlockLoaders: {
+    kind: "live-only",
+    reason: "opaque_batch_loader"
+  },
+  listPublicCourses: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicTeamMembers: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicProducts: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  listPublicPasses: {
+    kind: "live-only",
+    reason: "safety_sensitive_booking"
+  },
+  listPublicMemberships: {
+    kind: "live-only",
+    reason: "safety_sensitive_booking"
+  },
+  resolveEntrySubroute: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  resolveEventOccurrence: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  checkRedirect: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getRoutableContent: {
+    kind: "live-only",
+    reason: "auth_required"
+  },
+  getPublicRoutableContent: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  },
+  getPublicSitemapRoutes: {
+    kind: "memory-only",
+    reason: "durable_rollout_pending"
+  }
+};
+var PUBLIC_ENDPOINT_NAME_SET = new Set(PUBLIC_ENDPOINT_NAMES2);
+function isPublicEndpointName(endpoint) {
+  return PUBLIC_ENDPOINT_NAME_SET.has(endpoint);
+}
+function isTruthyParam(value) {
+  return value === true || value === "true" || value === 1 || value === "1";
+}
+function isPreviewRequest(endpoint, params) {
+  if (endpoint === "getContentByPath") {
+    return isTruthyParam(params.preview);
+  }
+  if (endpoint === "listPublishedEntries" || endpoint === "resolveEntrySubroute" || endpoint === "resolveEventOccurrence") {
+    return params.stage === "preview";
+  }
+  return false;
+}
+function getEndpointFreshTtlSec(endpoint) {
+  return API_ENDPOINTS2[endpoint].revalidate ?? DEFAULT_MEMORY_TTL_SEC;
+}
+function assertNever(value) {
+  throw new Error(`Unhandled runtime cache policy override: ${String(value)}`);
+}
+function resolveKnownEndpointPolicy(endpoint, params) {
+  if (isPreviewRequest(endpoint, params)) {
+    return { kind: "live-only", endpoint, reason: "preview_request" };
+  }
+  if (endpoint === "getSite" && isTruthyParam(params.force)) {
+    return { kind: "live-only", endpoint, reason: "force_refresh" };
+  }
+  const override = RUNTIME_CACHE_DURABILITY_OVERRIDES[endpoint];
+  if (override.kind === "live-only") {
+    return { kind: "live-only", endpoint, reason: override.reason };
+  }
+  const endpointDefinition = API_ENDPOINTS2[endpoint];
+  if (endpointDefinition.method !== "GET") {
+    return { kind: "live-only", endpoint, reason: "non_get_request" };
+  }
+  if (endpointDefinition.auth === "user") {
+    return { kind: "live-only", endpoint, reason: "auth_required" };
+  }
+  switch (override.kind) {
+    case "durable-public-stale":
+      return {
+        kind: "durable-public-stale",
+        endpoint,
+        freshTtlSec: getEndpointFreshTtlSec(endpoint),
+        staleTtlSec: override.staleTtlSec
+      };
+    case "memory-only":
+      return {
+        kind: "memory-only",
+        endpoint,
+        freshTtlSec: getEndpointFreshTtlSec(endpoint),
+        reason: override.reason
+      };
+    default:
+      return assertNever(override);
+  }
+}
+function resolveRuntimeCachePolicy(input) {
+  if (input.method && input.method.toUpperCase() !== "GET") {
+    return {
+      kind: "live-only",
+      endpoint: input.endpoint,
+      reason: "non_get_request"
+    };
+  }
+  if (!isPublicEndpointName(input.endpoint)) {
+    return {
+      kind: "live-only",
+      endpoint: input.endpoint,
+      reason: "unknown_endpoint"
+    };
+  }
+  return resolveKnownEndpointPolicy(input.endpoint, input.params ?? {});
+}
+function toNonEmptyString(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return null;
+  }
+  const normalized = String(value).trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function normalizeRuntimePublicPath(value) {
+  const raw = toNonEmptyString(value) ?? "/";
+  const withoutQuery = raw.split(/[?#]/, 1)[0] ?? "/";
+  const withLeadingSlash = withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+  const collapsed = withLeadingSlash.replace(/\/{2,}/g, "/");
+  const withoutTrailingSlash = collapsed.length > 1 ? collapsed.replace(/\/+$/g, "") : collapsed;
+  return withoutTrailingSlash || "/";
+}
+function normalizeRuntimeHostname(value) {
+  const trimmed = value.trim().toLowerCase();
+  const url = /^[a-z][a-z0-9+.-]*:\/\//.test(trimmed) ? new URL(trimmed) : new URL(`http://${trimmed}`);
+  return url.hostname.replace(/\.$/, "");
+}
+function normalizeScalar(value) {
+  return value.trim().toLowerCase();
+}
+function encodeKeyPart(key, value) {
+  return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+}
+function unsafeAsPublishedRuntimeCacheKey(value) {
+  return value;
+}
+function buildPublishedRuntimeCacheKey(endpoint, normalizedParams) {
+  const encodedParams = Object.entries(normalizedParams).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => encodeKeyPart(key, value)).join(":");
+  return unsafeAsPublishedRuntimeCacheKey(
+    `published-runtime:v1:${endpoint}:${encodedParams}`
+  );
+}
+function selectSiteRuntimeIdentity(params) {
+  const slug = toNonEmptyString(params.slug);
+  if (slug !== null) return { slug: normalizeScalar(slug) };
+  const domain = toNonEmptyString(params.domain);
+  if (domain !== null) return { domain: normalizeRuntimeHostname(domain) };
+  const id = toNonEmptyString(params.id);
+  if (id !== null) return { id: normalizeScalar(id) };
+  return null;
+}
+function deriveGetSiteKey(params) {
+  const identity = selectSiteRuntimeIdentity(params);
+  if (identity === null) {
+    return {
+      ok: false,
+      error: {
+        kind: "missing_site_identity",
+        acceptedParams: ["slug", "domain", "id"]
+      }
+    };
+  }
+  const normalizedParams = {
+    ...identity,
+    currentPath: normalizeRuntimePublicPath(params.currentPath)
+  };
+  return {
+    ok: true,
+    endpoint: "getSite",
+    key: buildPublishedRuntimeCacheKey("getSite", normalizedParams),
+    normalizedParams
+  };
+}
+function deriveGetContentByPathKey(params) {
+  const siteId = toNonEmptyString(params.siteId);
+  if (siteId === null) {
+    return {
+      ok: false,
+      error: {
+        kind: "missing_required_param",
+        endpoint: "getContentByPath",
+        param: "siteId"
+      }
+    };
+  }
+  const normalizedParams = {
+    siteId: normalizeScalar(siteId),
+    path: normalizeRuntimePublicPath(params.path)
+  };
+  return {
+    ok: true,
+    endpoint: "getContentByPath",
+    key: buildPublishedRuntimeCacheKey("getContentByPath", normalizedParams),
+    normalizedParams
+  };
+}
+var DURABLE_RUNTIME_CACHE_KEY_DERIVERS = {
+  getSite: deriveGetSiteKey,
+  getContentByPath: deriveGetContentByPathKey
+};
+function derivePublishedRuntimeCacheKey(input) {
+  const policy = resolveRuntimeCachePolicy({
+    endpoint: input.endpoint,
+    method: "GET",
+    params: input.params
+  });
+  if (policy.kind !== "durable-public-stale") {
+    return {
+      ok: false,
+      error: { kind: "not_durable_eligible", policy }
+    };
+  }
+  switch (input.endpoint) {
+    case "getSite":
+      return DURABLE_RUNTIME_CACHE_KEY_DERIVERS.getSite(input.params);
+    case "getContentByPath":
+      return DURABLE_RUNTIME_CACHE_KEY_DERIVERS.getContentByPath(input.params);
+  }
+}
+
 // src/client/resilience.ts
 var DEFAULT_RETRY_CONFIG = {
   maxAttempts: 3,
@@ -7508,12 +8031,57 @@ setSdkVersion(SDK_VERSION);
 var DEFAULT_BROWSER_TIMEOUT_MS = 5e3;
 var DEFAULT_SERVER_TIMEOUT_MS = 8e3;
 var MAX_GET_ENTRIES_BY_IDENTIFIERS_REFS = 50;
+function isDurableRuntimeCacheTier(cacheTier) {
+  return cacheTier === "durable-fresh" || cacheTier === "durable-stale";
+}
+function isDegradedResilienceStatus(source, details) {
+  return source === "stale" || source === "error" || isDurableRuntimeCacheTier(details.cacheTier) && details.error !== void 0;
+}
 function generateRequestId2() {
   return `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
 }
 function toRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
+function getRuntimePayloadSiteId(value) {
+  const site = toRecord(value).site;
+  if (!site || typeof site !== "object" || Array.isArray(site)) {
+    return null;
+  }
+  const id = site.id;
+  return typeof id === "string" && id.trim().length > 0 ? id : null;
+}
+function getRiverbankErrorInfo(error) {
+  if (error instanceof RiverbankApiError) {
+    return { code: error.code, message: error.message, status: error.status };
+  }
+  if (error instanceof Error) {
+    return { message: error.message };
+  }
+  return { message: String(error) };
+}
+function planPublishedRuntimeCache(input) {
+  const policy = resolveRuntimeCachePolicy({
+    endpoint: input.endpoint,
+    method: "GET",
+    params: input.params
+  });
+  if (policy.kind !== "durable-public-stale") {
+    return null;
+  }
+  const keyResult = derivePublishedRuntimeCacheKey(input);
+  if (!keyResult.ok) {
+    return null;
+  }
+  return {
+    cacheKey: keyResult.key,
+    endpoint: keyResult.endpoint,
+    normalizedParams: keyResult.normalizedParams,
+    freshTtlSec: policy.freshTtlSec,
+    staleTtlSec: policy.staleTtlSec,
+    siteId: input.siteId ?? null
+  };
+}
 function normalizeEntryIdentifierRefs(identifiers) {
   const trimmed = identifiers.map((identifier) => identifier.trim()).filter((identifier) => identifier.length > 0);
   if (trimmed.length === 0) {
@@ -7747,6 +8315,8 @@ function createRiverbankClient(config) {
       source,
       isPreview: details.isPreview,
       cacheKey: details.cacheKey,
+      cacheTier: details.cacheTier,
+      durableCache: details.durableCache,
       error: details.error,
       staleAgeSec: details.staleAgeSec,
       prebuildAgeSec: details.prebuildAgeSec,
@@ -7756,7 +8326,7 @@ function createRiverbankClient(config) {
     };
     lastStatus = status;
     config.resilience?.onStatusChange?.(status);
-    const nowDegraded = source === "stale" || source === "error";
+    const nowDegraded = isDegradedResilienceStatus(source, details);
     if (nowDegraded !== isDegraded) {
       isDegraded = nowDegraded;
       config.resilience?.onDegradedMode?.(nowDegraded, status);
@@ -7766,6 +8336,80 @@ function createRiverbankClient(config) {
       resilience: status
     };
   }
+  async function tryPublishedRuntimeCacheFallback(plan, statusDetails, errorInfo) {
+    const reader = config.publishedRuntimeCache?.read;
+    if (!plan || !reader) {
+      return null;
+    }
+    try {
+      const result = await reader({
+        cacheKey: plan.cacheKey,
+        endpoint: plan.endpoint,
+        payloadSchemaVersion: DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION
+      });
+      if (result.kind === "miss") {
+        return {
+          kind: "miss",
+          diagnostic: {
+            outcome: "miss",
+            reason: result.reason
+          }
+        };
+      }
+      if (result.kind === "error") {
+        return {
+          kind: "error",
+          diagnostic: {
+            outcome: "error",
+            error: result.error
+          }
+        };
+      }
+      return {
+        kind: "hit",
+        result: emitStatus(
+          result.freshness === "fresh" ? "cache" : "stale",
+          result.payload,
+          statusDetails({
+            error: errorInfo,
+            staleAgeSec: result.staleAgeSec,
+            cacheTier: result.freshness === "fresh" ? "durable-fresh" : "durable-stale"
+          })
+        )
+      };
+    } catch (error) {
+      return {
+        kind: "error",
+        diagnostic: {
+          outcome: "error",
+          error: {
+            kind: "adapter_exception",
+            message: error instanceof Error ? error.message : String(error)
+          }
+        }
+      };
+    }
+  }
+  async function writePublishedRuntimeCache(plan, payload) {
+    const writer = config.publishedRuntimeCache?.write;
+    if (!plan || !writer) {
+      return;
+    }
+    try {
+      await writer({
+        cacheKey: plan.cacheKey,
+        endpoint: plan.endpoint,
+        normalizedParams: plan.normalizedParams,
+        payload,
+        siteId: plan.siteId ?? getRuntimePayloadSiteId(payload),
+        freshTtlSec: plan.freshTtlSec,
+        staleTtlSec: plan.staleTtlSec,
+        payloadSchemaVersion: DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION,
+        writeReason: "live_success"
+      });
+    } catch {
+    }
+  }
   async function resilientFetch(cacheKey, fetcher, options) {
     const requestId = generateRequestId2();
     const startTime = Date.now();
@@ -7781,7 +8425,11 @@ function createRiverbankClient(config) {
     if (cacheEnabled && !options.force) {
       const fresh = cache.getFresh(cacheKey);
       if (fresh !== null) {
-        return emitStatus("cache", fresh, statusDetails());
+        return emitStatus(
+          "cache",
+          fresh,
+          statusDetails({ cacheTier: "memory-fresh" })
+        );
       }
     }
     if (resilienceEnabled && circuitBreaker.isOpen()) {
@@ -7793,6 +8441,7 @@ function createRiverbankClient(config) {
             stale.value,
             statusDetails({
               staleAgeSec: stale.staleAgeSec,
+              cacheTier: "memory-stale",
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -7801,6 +8450,15 @@ function createRiverbankClient(config) {
           );
         }
       }
+      const durableFallback = allowFallbacks && !isPreview ? await tryPublishedRuntimeCacheFallback(
+        options.publishedRuntimeCache,
+        statusDetails,
+        { code: "circuit_open", message: "Circuit breaker is open" }
+      ) : null;
+      const durableCache = durableFallback?.kind === "miss" || durableFallback?.kind === "error" ? durableFallback.diagnostic : void 0;
+      if (durableFallback?.kind === "hit") {
+        return durableFallback.result;
+      }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
@@ -7809,6 +8467,8 @@ function createRiverbankClient(config) {
             prebuildResult.data,
             statusDetails({
               prebuildAgeSec: prebuildResult.prebuildAgeSec,
+              cacheTier: "prebuild",
+              durableCache,
               error: {
                 code: "circuit_open",
                 message: "Circuit breaker is open"
@@ -7822,6 +8482,7 @@ function createRiverbankClient(config) {
         "error",
         null,
         statusDetails({
+          durableCache,
           error: { code: "circuit_open", message: "Circuit breaker is open" }
         })
       );
@@ -7862,6 +8523,9 @@ function createRiverbankClient(config) {
       if (cacheEnabled) {
         cache.set(cacheKey, data);
       }
+      if (allowFallbacks && !isPreview) {
+        await writePublishedRuntimeCache(options.publishedRuntimeCache, data);
+      }
       return emitStatus("live", data, statusDetails());
     } catch (error) {
       if (resilienceEnabled && error instanceof Error) {
@@ -7870,44 +8534,47 @@ 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,
-            status: error.status
-          } : { message: error.message };
+          const errorInfo2 = getRiverbankErrorInfo(error);
           return emitStatus(
             "stale",
             stale.value,
             statusDetails({
               staleAgeSec: stale.staleAgeSec,
+              cacheTier: "memory-stale",
               error: errorInfo2
             })
           );
         }
       }
+      const errorInfo = getRiverbankErrorInfo(error);
+      const durableFallback = allowFallbacks && !isPreview ? await tryPublishedRuntimeCacheFallback(
+        options.publishedRuntimeCache,
+        statusDetails,
+        errorInfo
+      ) : null;
+      const durableCache = durableFallback?.kind === "miss" || durableFallback?.kind === "error" ? durableFallback.diagnostic : void 0;
+      if (durableFallback?.kind === "hit") {
+        return durableFallback.result;
+      }
       if (allowFallbacks && !isPreview && options.prebuildFallback) {
         const prebuildResult = options.prebuildFallback();
         if (prebuildResult) {
-          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
+              cacheTier: "prebuild",
+              durableCache,
+              error: errorInfo
             })
           );
         }
       }
-      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 })
+        statusDetails({ error: errorInfo, durableCache })
       );
       throw attachResilienceStatusToError(error, failure.resilience);
     }
@@ -7957,8 +8624,12 @@ function createRiverbankClient(config) {
       );
     }
     const siteIdentifier = slug || domain || id;
-    const cacheKey = `site:${siteIdentifier ?? "unknown"}:${currentPath ?? ""}`;
     const siteId = id || slug || domain;
+    const publishedRuntimeCache = planPublishedRuntimeCache({
+      endpoint: "getSite",
+      params: { slug, domain, id, currentPath, force }
+    });
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `site:${siteIdentifier ?? "unknown"}:${currentPath ?? ""}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
@@ -7981,13 +8652,19 @@ function createRiverbankClient(config) {
       {
         signal,
         force,
+        publishedRuntimeCache,
         prebuildFallback: prebuildLoader && siteId ? () => prebuildLoader.loadSite(siteId) : void 0
       }
     );
   }
   async function getPageWithResilienceInternal(params) {
     const { siteId, path, preview = false, signal } = params;
-    const cacheKey = `page:${siteId}:${path}:${preview}`;
+    const publishedRuntimeCache = planPublishedRuntimeCache({
+      endpoint: "getContentByPath",
+      params: { siteId, path, preview },
+      siteId
+    });
+    const cacheKey = publishedRuntimeCache?.cacheKey ?? `page:${siteId}:${path}:${preview}`;
     return resilientFetch(
       cacheKey,
       async (sig) => {
@@ -8000,6 +8677,7 @@ function createRiverbankClient(config) {
       {
         preview,
         signal,
+        publishedRuntimeCache,
         // Prebuild fallback only for published pages (not preview)
         prebuildFallback: prebuildLoader && !preview ? () => prebuildLoader.loadPage(siteId, path) : void 0
       }
@@ -8545,7 +9223,7 @@ function err(error) {
 }
 
 // ../core/src/assert-never.ts
-function assertNever(value, message = "Unexpected variant") {
+function assertNever2(value, message = "Unexpected variant") {
   throw new Error(`${message}: ${String(value)}`);
 }
 
@@ -8869,7 +9547,7 @@ var navigationLinkInputSchema = z2.discriminatedUnion(
 );
 
 // ../api/src/sdkConfig/contracts.ts
-import { z as z65 } from "zod";
+import { z as z63 } from "zod";
 
 // ../blocks/src/system/manifest/augmentManifest.ts
 function augmentManifest(manifest) {
@@ -9195,12 +9873,17 @@ var visibleWhenPredicateSchema = z4.object({
   minItems: z4.number().int().nonnegative().optional(),
   maxItems: z4.number().int().nonnegative().optional()
 });
-var visibleWhenSchema = z4.union([
-  visibleWhenPredicateSchema,
-  z4.object({
-    allOf: z4.array(visibleWhenPredicateSchema).min(1)
-  })
-]);
+var visibleWhenSchema = z4.lazy(
+  () => z4.union([
+    visibleWhenPredicateSchema,
+    z4.object({
+      allOf: z4.array(visibleWhenSchema).min(1)
+    }),
+    z4.object({
+      anyOf: z4.array(visibleWhenSchema).min(1)
+    })
+  ])
+);
 var uiSchema = z4.object({
   widget: z4.string().optional(),
   // Container/widget presets (used by Group/Repeater widgets themselves, not for widget selection)
@@ -9964,7 +10647,7 @@ function makeBoundaryId(previousBlockId, nextBlockId) {
   const next = encodeURIComponent(nextBlockId);
   return asDesignBoundaryId(`boundary:${previous}:${next}`);
 }
-function assertNever2(value, message = "Unhandled Theme V2 variant") {
+function assertNever3(value, message = "Unhandled Theme V2 variant") {
   throw new Error(`${message}: ${String(value)}`);
 }
 function brandNonEmptyString(value, label) {
@@ -16345,7 +17028,7 @@ function themedHeaderShadow(theme) {
     case "high":
       return { elevation: "lg" };
     default:
-      return assertNever2(
+      return assertNever3(
         theme.shadow.elevation,
         "Unhandled theme shadow elevation"
       );
@@ -22186,9 +22869,6 @@ var heroCopyFragment = defineFragment({
       maxLength: 600
     }
   ],
-  // Layout order is [eyebrow, headline, subheadline]. The hero block's
-  // `splitEditorial` variant reads these nodes by index; keep the order stable
-  // (it fails fast at import if the count changes).
   layout: [
     text(
       {
@@ -24426,32 +25106,6 @@ var splitReverseLayout = splitLayoutWith([
   splitContentColumn,
   splitImageColumn
 ]);
-var heroEyebrowNode = heroCopyFragment.layout[0];
-var heroHeadlineNode = heroCopyFragment.layout[1];
-var heroSubheadlineNode = heroCopyFragment.layout[2];
-var heroCtaRowNode = heroCtaRowFragment.layout[0];
-if (!heroEyebrowNode || !heroHeadlineNode || !heroSubheadlineNode || !heroCtaRowNode) {
-  throw new Error("Hero copy/CTA fragments are missing their expected layout nodes.");
-}
-var heroEditorialBottomRow = inline(
-  {
-    gap: "lg",
-    align: "end",
-    justify: "start",
-    wrap: true,
-    className: "rb-w-full"
-  },
-  [heroSubheadlineNode, heroCtaRowNode]
-);
-var splitEditorialContentColumn = heroContentWrapper(
-  [heroEyebrowNode, heroHeadlineNode, heroEditorialBottomRow],
-  "md",
-  "rb-w-full rb-text-left"
-);
-var splitEditorialLayout = splitLayoutWith([
-  splitEditorialContentColumn,
-  splitImageColumn
-]);
 var heroConfig = {
   id: "block.hero",
   title: "Hero",
@@ -24475,7 +25129,8 @@ var heroConfig = {
       id: "imageShape",
       label: "Image shape",
       defaultValue: "default",
-      uiIntent: "display"
+      uiIntent: "display",
+      visibleWhen: { field: "variant", oneOf: ["split", "splitReverse"] }
     })
   ],
   layout: classicLayout,
@@ -24483,8 +25138,7 @@ var heroConfig = {
     classic: classicLayout,
     micro: microLayout,
     split: splitLayout,
-    splitReverse: splitReverseLayout,
-    splitEditorial: splitEditorialLayout
+    splitReverse: splitReverseLayout
   },
   defaultVariant: "classic",
   description: "Hero section with headline, subtitle, and repeatable CTAs.",
@@ -26360,8 +27014,10 @@ function resolveGeneratedHeroLayoutStyles(content) {
   return isPlainObject(raw) ? raw : null;
 }
 function readHeroLayoutString(content, generatedKey, fallbackKey = generatedKey) {
+  const explicitValue = readString(content, fallbackKey);
+  if (explicitValue !== void 0) return explicitValue;
   const generated = resolveGeneratedHeroLayoutStyles(content);
-  return generated && typeof generated[generatedKey] === "string" ? generated[generatedKey] : readString(content, fallbackKey);
+  return generated && typeof generated[generatedKey] === "string" ? generated[generatedKey] : void 0;
 }
 function resolveHeroVariant(content) {
   const variant = readString(content, "variant");
@@ -26374,7 +27030,7 @@ function resolveHeroContentAlignment(content) {
   const raw = readHeroLayoutString(content, "contentAlignment");
   if (raw === "left" || raw === "center" || raw === "right") return raw;
   const variant = resolveHeroVariant(content);
-  if (variant === "split" || variant === "splitReverse" || variant === "splitEditorial") return "left";
+  if (variant === "split" || variant === "splitReverse") return "left";
   return "center";
 }
 function resolveHeroVerticalAlignment(content) {
@@ -26384,7 +27040,7 @@ function resolveHeroVerticalAlignment(content) {
   const minHeight = sectionStyles?.minHeight;
   if (minHeight === "banner" || minHeight === "hero" || minHeight === "immersive") return "center";
   const variant = resolveHeroVariant(content);
-  if (variant === "split" || variant === "splitReverse" || variant === "splitEditorial") return "center";
+  if (variant === "split" || variant === "splitReverse") return "center";
   return "top";
 }
 function resolveHeroContentMaxWidth(content) {
@@ -26800,7 +27456,7 @@ function planSiteChromePlacement(positioning) {
         standaloneShellClassName: "fixed left-0 right-0 top-0 z-40 w-full"
       };
     default:
-      return assertNever2(positioning);
+      return assertNever3(positioning);
   }
 }
 
@@ -29953,9 +30609,6 @@ var appointmentBookingBlockDefinition = {
   }
 };
 
-// ../blocks/src/system/blocks/event-registration.ts
-import { z as z47 } from "zod";
-
 // ../blocks/src/system/blocks/events/shared/schemas.ts
 import { z as z43 } from "zod";
 
@@ -30577,24 +31230,57 @@ function normalizeEventStaffMemberId(value) {
   return trimmed ? trimmed : null;
 }
 
-// ../blocks/src/system/blocks/event-registration.shared.ts
+// ../blocks/src/system/blocks/shop.shared.ts
 import { z as z44 } from "zod";
-var occurrenceContextSchema = z44.object({
+var publicPassProductSchema = z44.object({
+  id: z44.string(),
+  productUseCase: z44.enum(["event_pass", "appointment_package"]).default("event_pass"),
+  name: z44.string(),
+  description: z44.string().nullable(),
+  price: z44.number(),
+  currency: z44.string(),
+  creditsTotal: z44.number(),
+  pricePerCredit: z44.number(),
+  validDays: z44.number().nullable(),
+  eligibleCategoryIds: z44.array(z44.string()),
+  eligibleCategoryNames: z44.array(z44.string())
+});
+var publicPassProductCollectionSchema = z44.object({
+  passes: z44.array(publicPassProductSchema)
+});
+var publicMembershipProductSchema = z44.object({
   id: z44.string(),
-  seriesId: z44.string(),
-  startsAt: z44.string(),
-  endsAt: z44.string(),
-  timeZone: z44.string(),
-  capacityOverride: z44.number().nullable().optional(),
-  overrides: z44.record(z44.string(), z44.unknown()).nullable().optional()
+  name: z44.string(),
+  description: z44.string().nullable(),
+  price: z44.number(),
+  currency: z44.string(),
+  billingInterval: z44.enum(["month", "year"]),
+  eligibleCategoryIds: z44.array(z44.string()),
+  eligibleCategoryNames: z44.array(z44.string())
+});
+var publicMembershipProductCollectionSchema = z44.object({
+  memberships: z44.array(publicMembershipProductSchema)
+});
+
+// ../blocks/src/system/blocks/event-registration.shared.ts
+import { z as z45 } from "zod";
+var occurrenceContextSchema = z45.object({
+  id: z45.string(),
+  seriesId: z45.string(),
+  startsAt: z45.string(),
+  endsAt: z45.string(),
+  timeZone: z45.string(),
+  capacityOverride: z45.number().nullable().optional(),
+  overrides: z45.record(z45.string(), z45.unknown()).nullable().optional()
 }).nullable();
 
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
-import { z as z46 } from "zod";
+import { z as z47 } from "zod";
 
 // ../blocks/src/system/constants/events.ts
 var EVENT_CONTENT_TYPE_SLUGS = ["event", "events"];
-var eventCalendarDisplayModeValues = ["combined", "month", "week", "list", "timetable"];
+var eventCalendarDisplayModeValues = ["combined", "calendar", "list", "timetable"];
+var eventCalendarDefaultViewValues = ["month", "week"];
 var eventCalendarListLayoutValues = ["stack", "grid", "compact"];
 var eventCalendarListLayoutOptions = [
   { id: "stack", label: "Stack" },
@@ -30604,6 +31290,9 @@ var eventCalendarListLayoutOptions = [
 function isEventCalendarDisplayMode(value) {
   return typeof value === "string" && eventCalendarDisplayModeValues.includes(value);
 }
+function isEventCalendarDefaultView(value) {
+  return typeof value === "string" && eventCalendarDefaultViewValues.includes(value);
+}
 function isEventCalendarListLayout(value) {
   return typeof value === "string" && eventCalendarListLayoutValues.includes(value);
 }
@@ -30744,16 +31433,17 @@ function readAmount(value) {
 }
 
 // ../blocks/src/system/runtime/nodes/shared/contract-schemas.ts
-import { z as z45 } from "zod";
-var previewStageSchema = z45.enum(["preview", "published"]);
-var registrationButtonVariantSchema = z45.enum(["primary", "secondary", "outline"]);
-var eventButtonVariantSchema = z45.enum(["primary", "secondary", "outline", "link"]);
-var eventLayoutSchema = z45.enum(eventCalendarListLayoutValues);
-var eventCalendarDisplayModeSchema = z45.enum(eventCalendarDisplayModeValues);
-var columnOptionSchema = z45.enum(["2", "3", "4"]);
-var weekStartSchema = z45.enum(["sunday", "monday"]);
-var filterAutoShowSchema = z45.enum(["auto", "always", "never"]);
-var calendarTabViewsSchema = z45.enum(["both", "month", "week"]);
+import { z as z46 } from "zod";
+var previewStageSchema = z46.enum(["preview", "published"]);
+var registrationButtonVariantSchema = z46.enum(["primary", "secondary", "outline"]);
+var eventButtonVariantSchema = z46.enum(["primary", "secondary", "outline", "link"]);
+var eventLayoutSchema = z46.enum(eventCalendarListLayoutValues);
+var eventCalendarDisplayModeSchema = z46.enum(eventCalendarDisplayModeValues);
+var eventCalendarDefaultViewSchema = z46.enum(eventCalendarDefaultViewValues);
+var columnOptionSchema = z46.enum(["2", "3", "4"]);
+var weekStartSchema = z46.enum(["sunday", "monday"]);
+var filterAutoShowSchema = z46.enum(["auto", "always", "never"]);
+var calendarTabViewsSchema = z46.enum(["both", "month", "week"]);
 
 // ../blocks/src/system/runtime/nodes/event-registration/wizardSteps.ts
 function getWizardStepsForContext(hasPreSelectedContext, needsPaymentStep) {
@@ -30771,7 +31461,7 @@ function eventMatchesOccurrenceId(event, occurrenceId) {
 function findPreSelectedEvent(input) {
   const occurrenceContext = input.occurrenceContext;
   if (!occurrenceContext) {
-    return null;
+    return input.scopedEvents.length === 1 ? input.scopedEvents[0] ?? null : null;
   }
   const contextDate = getBookingLocalDateKey(toScheduledBookingDateTime({
     startsAt: occurrenceContext.startsAt,
@@ -30813,68 +31503,72 @@ function toRegistrationEvents(events) {
 // ../blocks/src/system/runtime/nodes/event-registration.interactive.ts
 var EVENT_REGISTRATION_GENERIC_SHELL_STEP_LABELS = ["Date", "Tickets", "Details"];
 var EVENT_REGISTRATION_SHELL_STEP_LABELS = ["Event", "Date", "Tickets", "Details", "Payment"];
-var contentEntrySchema = z46.object({
-  id: z46.string(),
-  slug: z46.string(),
-  contentTypeSlug: z46.string()
+var contentEntrySchema = z47.object({
+  id: z47.string(),
+  slug: z47.string(),
+  contentTypeSlug: z47.string()
 });
-var eventRegistrationPublicEventSchema = z46.preprocess(
+var eventRegistrationPublicEventSchema = z47.preprocess(
   normalizeEventRegistrationEventInput,
   publicEventSchema
 );
-var eventRegistrationSourceSchema = z46.object({
-  siteId: z46.string().optional(),
-  apiBaseUrl: z46.string().optional(),
-  portalToken: z46.string().nullable().optional(),
-  previewToken: z46.string().nullable().optional(),
+var eventRegistrationSourceSchema = z47.object({
+  siteId: z47.string().optional(),
+  apiBaseUrl: z47.string().optional(),
+  portalToken: z47.string().nullable().optional(),
+  previewToken: z47.string().nullable().optional(),
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z46.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  className: z46.string().nullable().optional(),
-  buttonText: z46.string().nullable().optional(),
-  maxTickets: z46.string().nullable().optional(),
-  showVenue: z46.boolean().optional(),
-  showCapacity: z46.boolean().optional(),
-  successMessage: z46.string().optional(),
-  waitlistMessage: z46.string().optional(),
+  events: z47.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  className: z47.string().nullable().optional(),
+  buttonText: z47.string().nullable().optional(),
+  maxTickets: z47.string().nullable().optional(),
+  showVenue: z47.boolean().optional(),
+  showCapacity: z47.boolean().optional(),
+  successMessage: z47.string().optional(),
+  waitlistMessage: z47.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  overlayEnabled: z46.boolean().optional(),
-  spamProtectionEnabled: z46.boolean().optional(),
+  overlayEnabled: z47.boolean().optional(),
+  spamProtectionEnabled: z47.boolean().optional(),
   stage: previewStageSchema.optional(),
-  supportEmail: z46.string().optional()
-});
-var eventRegistrationDisplaySchema = z46.object({
-  kind: z46.literal("event-registration"),
-  state: z46.literal("generic-shell"),
-  className: z46.string().nullable(),
-  titleText: z46.string(),
-  bodyText: z46.string(),
-  stepLabels: z46.array(z46.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
-  summaryButtonText: z46.string()
-});
-var eventRegistrationHydrationSchema = z46.object({
+  supportEmail: z47.string().optional(),
+  sitePasses: publicPassProductCollectionSchema.nullable().optional(),
+  siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
+});
+var eventRegistrationDisplaySchema = z47.object({
+  kind: z47.literal("event-registration"),
+  state: z47.literal("generic-shell"),
+  className: z47.string().nullable(),
+  titleText: z47.string(),
+  bodyText: z47.string(),
+  stepLabels: z47.array(z47.enum(EVENT_REGISTRATION_SHELL_STEP_LABELS)).min(1),
+  summaryButtonText: z47.string()
+});
+var eventRegistrationHydrationSchema = z47.object({
   occurrenceContext: occurrenceContextSchema.optional(),
   contentEntry: contentEntrySchema.nullable().optional(),
-  events: z46.array(eventRegistrationPublicEventSchema).nullable().optional(),
-  maxTickets: z46.string().optional(),
-  showVenue: z46.boolean().optional(),
-  showCapacity: z46.boolean().optional(),
-  successMessage: z46.string().optional(),
-  waitlistMessage: z46.string().optional(),
+  events: z47.array(eventRegistrationPublicEventSchema).nullable().optional(),
+  maxTickets: z47.string().optional(),
+  showVenue: z47.boolean().optional(),
+  showCapacity: z47.boolean().optional(),
+  successMessage: z47.string().optional(),
+  waitlistMessage: z47.string().optional(),
   buttonVariant: registrationButtonVariantSchema.optional(),
-  overlayEnabled: z46.boolean().optional(),
-  spamProtectionEnabled: z46.boolean().optional(),
-  supportEmail: z46.string().optional()
+  overlayEnabled: z47.boolean().optional(),
+  spamProtectionEnabled: z47.boolean().optional(),
+  supportEmail: z47.string().optional(),
+  sitePasses: publicPassProductCollectionSchema.nullable().optional(),
+  siteMemberships: publicMembershipProductCollectionSchema.nullable().optional()
 });
-var eventRegistrationRenderSchema = z46.object({
+var eventRegistrationRenderSchema = z47.object({
   display: eventRegistrationDisplaySchema,
   hydration: eventRegistrationHydrationSchema
 });
-var eventRegistrationIslandMetaCodec = createZodCodec(z46.object({
-  siteId: z46.string().optional(),
-  apiBaseUrl: z46.string().optional(),
-  portalToken: z46.string().nullable().optional(),
-  previewToken: z46.string().nullable().optional(),
+var eventRegistrationIslandMetaCodec = createZodCodec(z47.object({
+  siteId: z47.string().optional(),
+  apiBaseUrl: z47.string().optional(),
+  portalToken: z47.string().nullable().optional(),
+  previewToken: z47.string().nullable().optional(),
   stage: previewStageSchema.optional()
 }));
 var eventRegistrationIslandMetaKeys = defineInteractiveIslandMetaKeys(
@@ -30980,7 +31674,9 @@ var eventRegistrationBlockRuntime = defineClientOwnedBlockRuntime({
       buttonVariant: source.buttonVariant,
       overlayEnabled: source.overlayEnabled,
       spamProtectionEnabled: source.spamProtectionEnabled,
-      supportEmail: source.supportEmail
+      supportEmail: source.supportEmail,
+      sitePasses: source.sitePasses ?? null,
+      siteMemberships: source.siteMemberships ?? null
     }
   })
 });
@@ -31162,6 +31858,8 @@ var eventRegistrationManifest = createBlockManifest({
               },
               // Event data from loader
               events: { $bind: { from: "data.events" } },
+              sitePasses: { $bind: { from: "data.sitePasses" } },
+              siteMemberships: { $bind: { from: "data.siteMemberships" } },
               // Stage for preview mode (allows registering for draft events)
               stage: {
                 $bind: { from: "$root.previewStage", fallback: "published" }
@@ -31180,7 +31878,9 @@ var eventRegistrationBlockDefinition = {
   manifest: eventRegistrationManifest,
   runtime: eventRegistrationBlockRuntime,
   dataSchemas: {
-    events: z47.array(publicEventSchema).optional(),
+    events: publicEventsArraySchema.optional(),
+    sitePasses: publicPassProductCollectionSchema.optional(),
+    siteMemberships: publicMembershipProductCollectionSchema.optional(),
     occurrenceContext: occurrenceContextSchema.optional()
   },
   dataLoaders: {
@@ -31199,6 +31899,20 @@ var eventRegistrationBlockDefinition = {
         entryId: { $bind: { from: "$root.contentEntry._entryId", fallback: "" } }
       },
       mode: "server"
+    },
+    sitePasses: {
+      endpoint: "listPublicPasses",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } }
+      },
+      mode: "server"
+    },
+    siteMemberships: {
+      endpoint: "listPublicMemberships",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } }
+      },
+      mode: "server"
     }
   }
 };
@@ -31530,35 +32244,7 @@ var courseRegistrationBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/event-details.ts
-import { z as z50 } from "zod";
-
-// ../blocks/src/system/blocks/shop.shared.ts
 import { z as z49 } from "zod";
-var publicPassProductSchema = z49.object({
-  id: z49.string(),
-  productUseCase: z49.enum(["event_pass", "appointment_package"]).default("event_pass"),
-  name: z49.string(),
-  description: z49.string().nullable(),
-  price: z49.number(),
-  currency: z49.string(),
-  creditsTotal: z49.number(),
-  pricePerCredit: z49.number(),
-  validDays: z49.number().nullable(),
-  eligibleCategoryIds: z49.array(z49.string()),
-  eligibleCategoryNames: z49.array(z49.string())
-});
-var publicMembershipProductSchema = z49.object({
-  id: z49.string(),
-  name: z49.string(),
-  description: z49.string().nullable(),
-  price: z49.number(),
-  currency: z49.string(),
-  billingInterval: z49.enum(["month", "year"]),
-  eligibleCategoryIds: z49.array(z49.string()),
-  eligibleCategoryNames: z49.array(z49.string())
-});
-
-// ../blocks/src/system/blocks/event-details.ts
 var eventDetailsManifest = createBlockManifest({
   id: "block.event-details",
   version: "1.0.0",
@@ -31690,40 +32376,40 @@ var eventDetailsManifest = createBlockManifest({
     })
   ]
 });
-var occurrenceContextSchema2 = z50.object({
-  id: z50.string(),
-  seriesId: z50.string(),
-  startsAt: z50.string(),
-  endsAt: z50.string(),
-  timeZone: z50.string(),
-  capacityOverride: z50.number().nullable().optional(),
-  overrides: z50.record(z50.string(), z50.unknown()).nullable().optional()
+var occurrenceContextSchema2 = z49.object({
+  id: z49.string(),
+  seriesId: z49.string(),
+  startsAt: z49.string(),
+  endsAt: z49.string(),
+  timeZone: z49.string(),
+  capacityOverride: z49.number().nullable().optional(),
+  overrides: z49.record(z49.string(), z49.unknown()).nullable().optional()
 }).nullable();
-var eventAutoApplyDiscountPreviewBaseSchema = z50.object({
-  id: z50.string(),
-  publicLabel: z50.string(),
-  description: z50.string().nullable(),
-  minTicketsRequired: z50.number().nullable()
+var eventAutoApplyDiscountPreviewBaseSchema = z49.object({
+  id: z49.string(),
+  publicLabel: z49.string(),
+  description: z49.string().nullable(),
+  minTicketsRequired: z49.number().nullable()
 });
-var eventAutoApplyDiscountPreviewSchema = z50.discriminatedUnion("discountType", [
+var eventAutoApplyDiscountPreviewSchema = z49.discriminatedUnion("discountType", [
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z50.literal("percent"),
-    discountPercent: z50.number(),
-    discountAmountCents: z50.null()
+    discountType: z49.literal("percent"),
+    discountPercent: z49.number(),
+    discountAmountCents: z49.null()
   }),
   eventAutoApplyDiscountPreviewBaseSchema.extend({
-    discountType: z50.literal("fixed"),
-    discountPercent: z50.null(),
-    discountAmountCents: z50.number()
+    discountType: z49.literal("fixed"),
+    discountPercent: z49.null(),
+    discountAmountCents: z49.number()
   })
 ]);
 var eventDetailsBlockDefinition = {
   manifest: eventDetailsManifest,
   dataSchemas: {
-    eventDetailsData: z50.object({
+    eventDetailsData: z49.object({
       events: publicEventsArraySchema,
-      sitePasses: z50.object({ passes: z50.array(publicPassProductSchema) }),
-      siteMemberships: z50.object({ memberships: z50.array(publicMembershipProductSchema) }),
+      sitePasses: publicPassProductCollectionSchema,
+      siteMemberships: publicMembershipProductCollectionSchema,
       autoApplyDiscount: eventAutoApplyDiscountPreviewSchema.nullable().optional().default(null)
     }).optional(),
     occurrenceContext: occurrenceContextSchema2.optional()
@@ -32047,7 +32733,7 @@ var eventSpotlightBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-import { z as z52 } from "zod";
+import { z as z51 } from "zod";
 
 // ../blocks/src/system/runtime/nodes/events/shared/utils.ts
 var COLUMN_CLASSES = {
@@ -32155,16 +32841,16 @@ function computeMediaTransformStyle(value, style, targetAspectRatio, options) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/shared/listOptions.ts
-import { z as z51 } from "zod";
+import { z as z50 } from "zod";
 var eventPageSizeValues = [3, 6, 10, 12, 20, 24, 30];
-var eventPageSizeSchema = z51.union([
-  z51.literal(3),
-  z51.literal(6),
-  z51.literal(10),
-  z51.literal(12),
-  z51.literal(20),
-  z51.literal(24),
-  z51.literal(30)
+var eventPageSizeSchema = z50.union([
+  z50.literal(3),
+  z50.literal(6),
+  z50.literal(10),
+  z50.literal(12),
+  z50.literal(20),
+  z50.literal(24),
+  z50.literal(30)
 ]);
 var eventPageSizeSet = new Set(eventPageSizeValues);
 function resolveEventPageSize(value, fallback = 12) {
@@ -32174,15 +32860,15 @@ function resolveEventPageSize(value, fallback = 12) {
 function resolveEventCalendarListPageSize(input) {
   return resolveEventPageSize(input.eventsPerPage);
 }
-var eventListPaginationActionSchema = z51.discriminatedUnion("kind", [
-  z51.object({
-    kind: z51.literal("loadMore"),
-    label: z51.string()
+var eventListPaginationActionSchema = z50.discriminatedUnion("kind", [
+  z50.object({
+    kind: z50.literal("loadMore"),
+    label: z50.string()
   }),
-  z51.object({
-    kind: z51.literal("seeAllLink"),
-    label: z51.string(),
-    href: z51.string()
+  z50.object({
+    kind: z50.literal("seeAllLink"),
+    label: z50.string(),
+    href: z50.string()
   })
 ]);
 function resolveEventListPaginationAction(input) {
@@ -32195,89 +32881,89 @@ function resolveEventListPaginationAction(input) {
 }
 
 // ../blocks/src/system/runtime/nodes/events/EventListing.interactive.ts
-var legacyEventCardVariantSchema = z52.enum(["variant1", "variant2"]);
-var eventCardVariantInputSchema = z52.union([
+var legacyEventCardVariantSchema = z51.enum(["variant1", "variant2"]);
+var eventCardVariantInputSchema = z51.union([
   cardVariantRoleSchema,
   legacyEventCardVariantSchema
 ]);
-var cardOrientationSchema = z52.enum(["vertical", "horizontal"]);
-var eventBlockKindSchema = z52.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema = z52.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema2 = z52.enum(eventScheduleScopeValues);
-var eventListingSourceSchema = z52.object({
-  events: z52.array(publicEventSchema).nullable().optional(),
-  siteId: z52.string(),
-  apiBaseUrl: z52.string().optional(),
+var cardOrientationSchema = z51.enum(["vertical", "horizontal"]);
+var eventBlockKindSchema = z51.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema = z51.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema2 = z51.enum(eventScheduleScopeValues);
+var eventListingSourceSchema = z51.object({
+  events: z51.array(publicEventSchema).nullable().optional(),
+  siteId: z51.string(),
+  apiBaseUrl: z51.string().optional(),
   stage: previewStageSchema.optional(),
   layout: eventLayoutSchema.optional(),
   columns: columnOptionSchema.optional(),
-  eventsPerPage: z52.string().optional(),
-  paginationMode: z52.enum(["loadMore", "seeAllLink"]).optional(),
-  seeAllUrl: z52.string().optional(),
-  loadMoreText: z52.string().optional(),
+  eventsPerPage: z51.string().optional(),
+  paginationMode: z51.enum(["loadMore", "seeAllLink"]).optional(),
+  seeAllUrl: z51.string().optional(),
+  loadMoreText: z51.string().optional(),
   cardVariant: eventCardVariantInputSchema.optional(),
   buttonVariant: eventButtonVariantSchema.optional(),
-  buttonText: z52.string().optional(),
-  showVenue: z52.boolean().optional(),
-  showMap: z52.boolean().optional(),
-  showCapacity: z52.boolean().optional(),
-  emptyMessage: z52.string().optional(),
-  className: z52.string().optional(),
-  showFilters: z52.boolean().nullable().optional(),
+  buttonText: z51.string().optional(),
+  showVenue: z51.boolean().optional(),
+  showMap: z51.boolean().optional(),
+  showCapacity: z51.boolean().optional(),
+  emptyMessage: z51.string().optional(),
+  className: z51.string().optional(),
+  showFilters: z51.boolean().nullable().optional(),
   showCategoryFilter: filterAutoShowSchema.optional(),
-  showVenueFilter: z52.boolean().nullable().optional(),
-  showStaffFilter: z52.boolean().nullable().optional(),
+  showVenueFilter: z51.boolean().nullable().optional(),
+  showStaffFilter: z51.boolean().nullable().optional(),
   eventKind: eventBlockKindSchema.nullable().optional(),
   eventSurface: eventSurfaceScopeSchema.nullable().optional(),
-  filterEventPresets: z52.union([z52.string(), z52.array(z52.string())]).nullable().optional(),
+  filterEventPresets: z51.union([z51.string(), z51.array(z51.string())]).nullable().optional(),
   scheduleScope: eventScheduleScopeSchema2.nullable().optional(),
-  filterCategoryIds: z52.string().nullable().optional(),
-  filterStaffMemberId: z52.string().nullable().optional(),
-  filterVenueId: z52.string().nullable().optional()
+  filterCategoryIds: z51.string().nullable().optional(),
+  filterStaffMemberId: z51.string().nullable().optional(),
+  filterVenueId: z51.string().nullable().optional()
 });
-var eventListingDisplaySchema = z52.object({
-  kind: z52.literal("event-listing"),
-  state: z52.enum(["loading", "empty", "ready"]),
+var eventListingDisplaySchema = z51.object({
+  kind: z51.literal("event-listing"),
+  state: z51.enum(["loading", "empty", "ready"]),
   listLayout: eventLayoutSchema,
-  className: z52.string().nullable(),
-  emptyMessage: z52.string(),
-  loadingMessage: z52.string(),
-  containerClass: z52.string(),
+  className: z51.string().nullable(),
+  emptyMessage: z51.string(),
+  loadingMessage: z51.string(),
+  containerClass: z51.string(),
   cardVariant: cardVariantRoleSchema,
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z52.string(),
-  showVenue: z52.boolean(),
-  showMap: z52.boolean(),
-  showCapacity: z52.boolean(),
+  buttonText: z51.string(),
+  showVenue: z51.boolean(),
+  showMap: z51.boolean(),
+  showCapacity: z51.boolean(),
   orientation: cardOrientationSchema,
-  events: z52.array(publicEventSchema)
+  events: z51.array(publicEventSchema)
 });
-var eventListingHydrationSchema = z52.object({
-  siteId: z52.string(),
+var eventListingHydrationSchema = z51.object({
+  siteId: z51.string(),
   stage: previewStageSchema.optional(),
   eventsPerPage: eventPageSizeSchema,
   paginationAction: eventListPaginationActionSchema,
-  showFilters: z52.boolean(),
+  showFilters: z51.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z52.boolean(),
-  showStaffFilter: z52.boolean(),
+  showVenueFilter: z51.boolean(),
+  showStaffFilter: z51.boolean(),
   eventKind: eventBlockKindSchema,
   eventSurface: eventSurfaceScopeSchema,
-  filterEventPresets: z52.string().nullable(),
+  filterEventPresets: z51.string().nullable(),
   scheduleScope: eventScheduleScopeSchema2,
-  filterCategoryIds: z52.string().nullable().optional(),
-  filterStaffMemberId: z52.string().nullable().optional(),
-  filterVenueId: z52.string().nullable().optional(),
-  fetchInitialEventsOnMount: z52.boolean()
+  filterCategoryIds: z51.string().nullable().optional(),
+  filterStaffMemberId: z51.string().nullable().optional(),
+  filterVenueId: z51.string().nullable().optional(),
+  fetchInitialEventsOnMount: z51.boolean()
 });
-var eventListingRenderSchema = z52.object({
+var eventListingRenderSchema = z51.object({
   display: eventListingDisplaySchema,
   hydration: eventListingHydrationSchema
 });
 var eventListingIslandMetaCodec = createZodCodec(
-  z52.object({
-    siteId: z52.string(),
-    apiBaseUrl: z52.string().optional(),
+  z51.object({
+    siteId: z51.string(),
+    apiBaseUrl: z51.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -32644,15 +33330,15 @@ var eventListingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/events/EventCalendar.interactive.ts
-import { z as z53 } from "zod";
-var eventBlockKindSchema2 = z53.enum(eventBlockKindValues);
-var eventSurfaceScopeSchema2 = z53.enum(eventSurfaceScopeValues);
-var eventScheduleScopeSchema3 = z53.enum(eventScheduleScopeValues);
-var eventCalendarSourceSchema = z53.object(
+import { z as z52 } from "zod";
+var eventBlockKindSchema2 = z52.enum(eventBlockKindValues);
+var eventSurfaceScopeSchema2 = z52.enum(eventSurfaceScopeValues);
+var eventScheduleScopeSchema3 = z52.enum(eventScheduleScopeValues);
+var eventCalendarSourceSchema = z52.object(
   {
-    events: z53.array(publicEventSchema).nullable().optional(),
-    siteId: z53.string(),
-    apiBaseUrl: z53.string().optional(),
+    events: z52.array(publicEventSchema).nullable().optional(),
+    siteId: z52.string(),
+    apiBaseUrl: z52.string().optional(),
     stage: previewStageSchema.optional(),
     variant: eventCalendarDisplayModeSchema.nullable().optional(),
     displayMode: eventCalendarDisplayModeSchema.nullable().optional(),
@@ -32660,78 +33346,80 @@ var eventCalendarSourceSchema = z53.object(
     listColumns: columnOptionSchema.optional(),
     layout: eventLayoutSchema.optional(),
     columns: columnOptionSchema.optional(),
-    eventsPerPage: z53.string().optional(),
-    paginationMode: z53.enum(["loadMore", "seeAllLink"]).optional(),
-    seeAllUrl: z53.string().optional(),
-    loadMoreText: z53.string().optional(),
+    eventsPerPage: z52.string().optional(),
+    paginationMode: z52.enum(["loadMore", "seeAllLink"]).optional(),
+    seeAllUrl: z52.string().optional(),
+    loadMoreText: z52.string().optional(),
     startOfWeek: weekStartSchema.optional(),
     calendarTabViews: calendarTabViewsSchema.optional(),
-    showFilters: z53.boolean().nullable().optional(),
+    defaultCalendarView: eventCalendarDefaultViewSchema.optional(),
+    showFilters: z52.boolean().nullable().optional(),
     showCategoryFilter: filterAutoShowSchema.optional(),
-    showVenueFilter: z53.boolean().nullable().optional(),
-    showStaffFilter: z53.boolean().nullable().optional(),
+    showVenueFilter: z52.boolean().nullable().optional(),
+    showStaffFilter: z52.boolean().nullable().optional(),
     kind: eventBlockKindSchema2.nullable().optional(),
     eventSurface: eventSurfaceScopeSchema2.nullable().optional(),
-    filterEventPresets: z53.union([z53.string(), z53.array(z53.string())]).nullable().optional(),
+    filterEventPresets: z52.union([z52.string(), z52.array(z52.string())]).nullable().optional(),
     scheduleScope: eventScheduleScopeSchema3.nullable().optional(),
-    filterCategoryIds: z53.union([z53.string(), z53.array(z53.string())]).nullable().optional(),
-    filterStaffMemberId: z53.string().nullable().optional(),
-    filterVenueId: z53.string().nullable().optional(),
+    filterCategoryIds: z52.union([z52.string(), z52.array(z52.string())]).nullable().optional(),
+    filterStaffMemberId: z52.string().nullable().optional(),
+    filterVenueId: z52.string().nullable().optional(),
     buttonVariant: eventButtonVariantSchema.optional(),
-    buttonText: z53.string().optional(),
-    showVenue: z53.boolean().nullable().optional(),
-    showMap: z53.boolean().nullable().optional(),
-    showCapacity: z53.boolean().nullable().optional(),
-    emptyMessage: z53.string().optional(),
-    className: z53.string().optional()
+    buttonText: z52.string().optional(),
+    showVenue: z52.boolean().nullable().optional(),
+    showMap: z52.boolean().nullable().optional(),
+    showCapacity: z52.boolean().nullable().optional(),
+    emptyMessage: z52.string().optional(),
+    className: z52.string().optional()
   }
 );
-var eventCalendarDisplaySchema = z53.object({
-  kind: z53.literal("event-calendar"),
+var eventCalendarDisplaySchema = z52.object({
+  kind: z52.literal("event-calendar"),
   displayMode: eventCalendarDisplayModeSchema,
-  className: z53.string().nullable(),
-  events: z53.array(publicEventSchema),
+  className: z52.string().nullable(),
+  events: z52.array(publicEventSchema),
   listLayout: eventLayoutSchema,
   listColumns: columnOptionSchema,
   eventsPerPage: eventPageSizeSchema,
   paginationAction: eventListPaginationActionSchema,
   startOfWeek: weekStartSchema,
   calendarTabViews: calendarTabViewsSchema,
-  showFilters: z53.boolean(),
+  defaultCalendarView: eventCalendarDefaultViewSchema,
+  showFilters: z52.boolean(),
   showCategoryFilter: filterAutoShowSchema,
-  showVenueFilter: z53.boolean(),
-  showStaffFilter: z53.boolean(),
+  showVenueFilter: z52.boolean(),
+  showStaffFilter: z52.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z53.string().nullable(),
+  filterEventPresets: z52.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3,
-  filterCategoryIds: z53.string().nullable(),
-  filterStaffMemberId: z53.string().nullable(),
-  filterVenueId: z53.string().nullable(),
+  filterCategoryIds: z52.string().nullable(),
+  filterStaffMemberId: z52.string().nullable(),
+  filterVenueId: z52.string().nullable(),
   buttonVariant: eventButtonVariantSchema,
-  buttonText: z53.string(),
-  showVenue: z53.boolean(),
-  showMap: z53.boolean(),
-  showCapacity: z53.boolean(),
-  emptyMessage: z53.string()
-});
-var eventCalendarHydrationSchema = z53.object({
-  siteId: z53.string(),
+  buttonText: z52.string(),
+  showVenue: z52.boolean(),
+  showMap: z52.boolean(),
+  showCapacity: z52.boolean(),
+  emptyMessage: z52.string()
+});
+var eventCalendarHydrationSchema = z52.object({
+  siteId: z52.string(),
   stage: previewStageSchema.optional(),
-  prefetchedEvents: z53.boolean(),
+  prefetchedEvents: z52.boolean(),
   eventKind: eventBlockKindSchema2,
   eventSurface: eventSurfaceScopeSchema2,
-  filterEventPresets: z53.string().nullable(),
+  filterEventPresets: z52.string().nullable(),
   scheduleScope: eventScheduleScopeSchema3
 });
-var eventCalendarRenderSchema = z53.object({
+var eventCalendarRenderSchema = z52.object({
   display: eventCalendarDisplaySchema,
   hydration: eventCalendarHydrationSchema
 });
 var eventCalendarIslandMetaCodec = createZodCodec(
-  z53.object({
-    siteId: z53.string(),
-    apiBaseUrl: z53.string().optional(),
+  z52.object({
+    siteId: z52.string(),
+    apiBaseUrl: z52.string().optional(),
     stage: previewStageSchema.optional()
   })
 );
@@ -32761,6 +33449,7 @@ function buildEventCalendarDisplay(source) {
     }),
     startOfWeek: source.startOfWeek ?? "monday",
     calendarTabViews: source.calendarTabViews ?? "both",
+    defaultCalendarView: source.defaultCalendarView ?? "month",
     showFilters: source.showFilters ?? true,
     showCategoryFilter: source.showCategoryFilter ?? "auto",
     showVenueFilter: source.showVenueFilter ?? false,
@@ -32823,6 +33512,9 @@ function normalizeEventCalendarContent(content) {
     ...variant ? { variant } : {},
     displayMode: normalizeEventCalendarDisplayMode(record.displayMode),
     listLayout: normalizeEventCalendarListLayout(record.listLayout),
+    defaultCalendarView: normalizeEventCalendarDefaultView(
+      record.defaultCalendarView
+    ),
     kind,
     eventSurface: normalizeEventSurfaceScope(record.eventSurface),
     filterEventPresets: normalizeEventSurfacePresets(record.filterEventPresets),
@@ -32840,6 +33532,9 @@ function normalizeEventCalendarDisplayMode(value) {
 function normalizeEventCalendarListLayout(value) {
   return isEventCalendarListLayout(value) ? value : void 0;
 }
+function normalizeEventCalendarDefaultView(value) {
+  return isEventCalendarDefaultView(value) ? value : void 0;
+}
 var eventCalendarLayout = [
   styledSection({
     children: sectionContainer(
@@ -32899,6 +33594,9 @@ var eventCalendarLayout = [
             calendarTabViews: {
               $bind: { from: "content.calendarTabViews", fallback: "both" }
             },
+            defaultCalendarView: {
+              $bind: { from: "content.defaultCalendarView", fallback: "month" }
+            },
             // Filtering options
             showFilters: {
               $bind: { from: "content.showFilters", fallback: true }
@@ -32965,8 +33663,7 @@ var eventCalendarAdditionalFields = [
     defaultValue: "combined",
     options: [
       { value: "combined", label: "Combined (List + Calendar tabs)" },
-      { value: "month", label: "Month calendar" },
-      { value: "week", label: "Week agenda" },
+      { value: "calendar", label: "Calendar" },
       { value: "timetable", label: "Timetable" },
       { value: "list", label: "List" }
     ],
@@ -33005,7 +33702,12 @@ var eventCalendarAdditionalFields = [
     ],
     ui: {
       intent: "display",
-      visibleWhen: { field: "listLayout", equals: "grid" }
+      visibleWhen: {
+        allOf: [
+          { field: "variant", oneOf: ["combined", "list"] },
+          { field: "listLayout", equals: "grid" }
+        ]
+      }
     }
   },
   {
@@ -33053,7 +33755,12 @@ var eventCalendarAdditionalFields = [
     required: false,
     ui: {
       intent: "display",
-      visibleWhen: { field: "paginationMode", equals: "seeAllLink" }
+      visibleWhen: {
+        allOf: [
+          { field: "variant", oneOf: ["combined", "list"] },
+          { field: "paginationMode", equals: "seeAllLink" }
+        ]
+      }
     }
   },
   {
@@ -33086,7 +33793,7 @@ var eventCalendarAdditionalFields = [
       intent: "display",
       visibleWhen: {
         field: "variant",
-        oneOf: ["combined", "month", "week"]
+        oneOf: ["combined", "calendar", "timetable"]
       }
     }
   },
@@ -33109,6 +33816,33 @@ var eventCalendarAdditionalFields = [
       visibleWhen: { field: "variant", equals: "combined" }
     }
   },
+  {
+    id: "defaultCalendarView",
+    type: "select",
+    label: "Calendar view",
+    description: "Choose the standalone calendar view, or the first view in combined mode",
+    required: false,
+    multiple: false,
+    defaultValue: "month",
+    options: [
+      { value: "month", label: "Month" },
+      { value: "week", label: "Week" }
+    ],
+    ui: {
+      intent: "display",
+      visibleWhen: {
+        anyOf: [
+          { field: "variant", equals: "calendar" },
+          {
+            allOf: [
+              { field: "variant", equals: "combined" },
+              { field: "calendarTabViews", equals: "both" }
+            ]
+          }
+        ]
+      }
+    }
+  },
   // Filtering options
   {
     id: "kind",
@@ -33136,7 +33870,7 @@ var eventCalendarAdditionalFields = [
       intent: "display",
       visibleWhen: {
         field: "variant",
-        oneOf: ["combined", "list", "timetable"]
+        oneOf: ["combined", "calendar", "list", "timetable"]
       }
     }
   },
@@ -33156,8 +33890,10 @@ var eventCalendarAdditionalFields = [
     ui: {
       intent: "display",
       visibleWhen: {
-        field: "variant",
-        oneOf: ["combined", "list", "timetable"]
+        allOf: [
+          { field: "variant", oneOf: ["combined", "calendar", "list", "timetable"] },
+          { field: "showFilters", equals: true }
+        ]
       }
     }
   },
@@ -33171,8 +33907,10 @@ var eventCalendarAdditionalFields = [
     ui: {
       intent: "display",
       visibleWhen: {
-        field: "variant",
-        oneOf: ["combined", "list", "timetable"]
+        allOf: [
+          { field: "variant", oneOf: ["combined", "calendar", "list", "timetable"] },
+          { field: "showFilters", equals: true }
+        ]
       }
     }
   },
@@ -33186,8 +33924,10 @@ var eventCalendarAdditionalFields = [
     ui: {
       intent: "display",
       visibleWhen: {
-        field: "variant",
-        oneOf: ["combined", "list", "timetable"]
+        allOf: [
+          { field: "variant", oneOf: ["combined", "calendar", "list", "timetable"] },
+          { field: "showFilters", equals: true }
+        ]
       }
     }
   },
@@ -33201,8 +33941,15 @@ var eventCalendarAdditionalFields = [
     ui: {
       intent: "display",
       visibleWhen: {
-        field: "variant",
-        oneOf: ["combined", "list", "week", "timetable"]
+        anyOf: [
+          { field: "variant", oneOf: ["combined", "list", "timetable"] },
+          {
+            allOf: [
+              { field: "variant", equals: "calendar" },
+              { field: "defaultCalendarView", equals: "week" }
+            ]
+          }
+        ]
       }
     }
   },
@@ -33318,8 +34065,7 @@ var eventCalendarAdditionalFields = [
 ];
 var eventCalendarVariants = {
   combined: eventCalendarLayout[0],
-  month: eventCalendarLayout[0],
-  week: eventCalendarLayout[0],
+  calendar: eventCalendarLayout[0],
   timetable: eventCalendarLayout[0],
   list: eventCalendarLayout[0]
 };
@@ -33331,8 +34077,7 @@ var eventCalendarDerivedFields = [
     multiple: false,
     options: [
       { value: "combined" },
-      { value: "month" },
-      { value: "week" },
+      { value: "calendar" },
       { value: "timetable" },
       { value: "list" }
     ]
@@ -33345,6 +34090,13 @@ var eventCalendarDerivedFields = [
     options: eventCalendarListLayoutOptions.map((option) => ({
       value: option.id
     }))
+  },
+  {
+    id: "defaultCalendarView",
+    type: "select",
+    required: false,
+    multiple: false,
+    options: [{ value: "month" }, { value: "week" }]
   }
 ];
 var eventCalendarContentShape = {
@@ -33393,8 +34145,7 @@ var eventCalendarConfig = {
   defaultVariant: "combined",
   variantOptions: {
     combined: { label: "Combined" },
-    month: { label: "Month" },
-    week: { label: "Week" },
+    calendar: { label: "Calendar" },
     timetable: { label: "Timetable" },
     list: { label: "List" }
   }
@@ -33440,7 +34191,7 @@ var eventCalendarBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-import { z as z54 } from "zod";
+import { z as z53 } from "zod";
 
 // ../blocks/src/system/blocks/offerings-preview/model.ts
 var OFFERINGS_PREVIEW_DEFAULT_ITEM_LIMIT = "3";
@@ -33532,13 +34283,13 @@ function isRecord5(value) {
 }
 
 // ../blocks/src/system/blocks/offerings-preview/index.ts
-var publicRouteCandidatesSchema = z54.object({
-  routes: z54.array(z54.object({
-    entityId: z54.string(),
-    path: z54.string(),
-    title: z54.string(),
-    kind: z54.enum(["page", "content"]),
-    contentTypeKey: z54.string().nullable().optional()
+var publicRouteCandidatesSchema = z53.object({
+  routes: z53.array(z53.object({
+    entityId: z53.string(),
+    path: z53.string(),
+    title: z53.string(),
+    kind: z53.enum(["page", "content"]),
+    contentTypeKey: z53.string().nullable().optional()
   }))
 });
 var groupOverrideFields = [
@@ -33936,7 +34687,7 @@ function isRecord6(value) {
 }
 
 // ../blocks/src/system/blocks/embed.ts
-import { z as z55 } from "zod";
+import { z as z54 } from "zod";
 var embedFields = [
   // Section heading
   parseFieldDefinition({
@@ -34167,18 +34918,18 @@ var embedManifest = createBlockManifest({
     spacing: "lg"
   }
 });
-var embedEntrySchema = z55.object({
-  id: z55.string(),
-  identifier: z55.string(),
-  title: z55.string(),
-  slug: z55.string().nullable().optional(),
-  content: z55.record(z55.string(), z55.unknown()).optional(),
-  publishedAt: z55.string().nullable().optional()
+var embedEntrySchema = z54.object({
+  id: z54.string(),
+  identifier: z54.string(),
+  title: z54.string(),
+  slug: z54.string().nullable().optional(),
+  content: z54.record(z54.string(), z54.unknown()).optional(),
+  publishedAt: z54.string().nullable().optional()
 });
 var embedBlockDefinition = {
   manifest: embedManifest,
   dataSchemas: {
-    entries: z55.array(embedEntrySchema).optional()
+    entries: z54.array(embedEntrySchema).optional()
   },
   dataLoaders: {
     entries: {
@@ -35361,57 +36112,54 @@ var fileDownloadBlockDefinition = {
   manifest: fileDownloadManifest
 };
 
-// ../blocks/src/system/blocks/shop.ts
-import { z as z59 } from "zod";
-
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-import { z as z58 } from "zod";
+import { z as z57 } from "zod";
 
 // ../blocks/src/system/blocks/products/shared.ts
-import { z as z56 } from "zod";
-var publicProductVariantSchema = z56.object({
-  id: z56.string(),
-  title: z56.string(),
-  sku: z56.string().nullable(),
-  priceCents: z56.number(),
-  stockQuantity: z56.number().nullable(),
-  soldOut: z56.boolean()
-});
-var publicProductSchema = z56.object({
-  id: z56.string(),
-  contentEntryId: z56.string().nullable(),
-  title: z56.string(),
-  slug: z56.string(),
-  path: z56.string().nullable(),
-  status: z56.enum(["draft", "active"]),
-  priceCents: z56.number(),
-  currency: z56.string(),
-  productType: z56.enum(["physical", "digital"]),
-  requiresShipping: z56.boolean(),
-  hasVariants: z56.boolean(),
-  trackInventory: z56.boolean(),
-  soldOut: z56.boolean(),
-  category: z56.object({
-    id: z56.string(),
-    name: z56.string(),
-    slug: z56.string()
+import { z as z55 } from "zod";
+var publicProductVariantSchema = z55.object({
+  id: z55.string(),
+  title: z55.string(),
+  sku: z55.string().nullable(),
+  priceCents: z55.number(),
+  stockQuantity: z55.number().nullable(),
+  soldOut: z55.boolean()
+});
+var publicProductSchema = z55.object({
+  id: z55.string(),
+  contentEntryId: z55.string().nullable(),
+  title: z55.string(),
+  slug: z55.string(),
+  path: z55.string().nullable(),
+  status: z55.enum(["draft", "active"]),
+  priceCents: z55.number(),
+  currency: z55.string(),
+  productType: z55.enum(["physical", "digital"]),
+  requiresShipping: z55.boolean(),
+  hasVariants: z55.boolean(),
+  trackInventory: z55.boolean(),
+  soldOut: z55.boolean(),
+  category: z55.object({
+    id: z55.string(),
+    name: z55.string(),
+    slug: z55.string()
   }).nullable(),
-  summary: z56.string().nullable(),
-  body: z56.unknown().nullable(),
-  gallery: z56.array(
-    z56.object({
-      url: z56.string(),
-      alt: z56.string().nullable()
+  summary: z55.string().nullable(),
+  body: z55.unknown().nullable(),
+  gallery: z55.array(
+    z55.object({
+      url: z55.string(),
+      alt: z55.string().nullable()
     })
   ),
-  variants: z56.array(publicProductVariantSchema)
+  variants: z55.array(publicProductVariantSchema)
 });
-var publicProductsResponseSchema = z56.object({
-  products: z56.array(publicProductSchema)
+var publicProductsResponseSchema = z55.object({
+  products: z55.array(publicProductSchema)
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
-function assertNever3(value) {
+function assertNever4(value) {
   throw new Error(`Unhandled credit product case: ${String(value)}`);
 }
 function useCasesFromModules(modules) {
@@ -35444,7 +36192,7 @@ function getCreditProductCreditUnit(useCase) {
         perCreditSuffix: "credit"
       };
     default:
-      return assertNever3(useCase);
+      return assertNever4(useCase);
   }
 }
 function deriveCreditProductLabels(products, options = {}) {
@@ -35471,27 +36219,27 @@ function deriveCreditProductLabels(products, options = {}) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop-commerce.shared.ts
-import { z as z57 } from "zod";
-var storedProductCartItemSchema = z57.object({
-  kind: z57.literal("product"),
-  productId: z57.string().min(1),
-  productCategoryId: z57.string().min(1).optional().nullable(),
-  variantId: z57.string().min(1).optional().nullable(),
-  title: z57.string().min(1),
-  variantTitle: z57.string().optional().nullable(),
-  quantity: z57.number().finite(),
-  unitPriceCents: z57.number().finite(),
-  currency: z57.string().min(1),
-  imageUrl: z57.string().optional().nullable(),
-  soldOut: z57.boolean().optional()
-});
-var storedPassCartItemSchema = z57.object({
-  kind: z57.literal("pass"),
-  passId: z57.string().min(1),
-  title: z57.string().min(1),
-  quantity: z57.number().finite().optional(),
-  unitPriceCents: z57.number().finite(),
-  currency: z57.string().min(1)
+import { z as z56 } from "zod";
+var storedProductCartItemSchema = z56.object({
+  kind: z56.literal("product"),
+  productId: z56.string().min(1),
+  productCategoryId: z56.string().min(1).optional().nullable(),
+  variantId: z56.string().min(1).optional().nullable(),
+  title: z56.string().min(1),
+  variantTitle: z56.string().optional().nullable(),
+  quantity: z56.number().finite(),
+  unitPriceCents: z56.number().finite(),
+  currency: z56.string().min(1),
+  imageUrl: z56.string().optional().nullable(),
+  soldOut: z56.boolean().optional()
+});
+var storedPassCartItemSchema = z56.object({
+  kind: z56.literal("pass"),
+  passId: z56.string().min(1),
+  title: z56.string().min(1),
+  quantity: z56.number().finite().optional(),
+  unitPriceCents: z56.number().finite(),
+  currency: z56.string().min(1)
 });
 function deriveCommerceCheckoutState(state) {
   if (state.items.length === 0) {
@@ -35725,214 +36473,214 @@ function formatValidity(days) {
 }
 
 // ../blocks/src/system/runtime/nodes/shop.interactive.ts
-var shopModeSchema = z58.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
-var contentEntrySchema3 = z58.object({
-  id: z58.string().nullable().optional(),
-  slug: z58.string().nullable().optional()
+var shopModeSchema = z57.enum(["passes-memberships", "product-list", "product-detail", "cart", "checkout"]);
+var contentEntrySchema3 = z57.object({
+  id: z57.string().nullable().optional(),
+  slug: z57.string().nullable().optional()
 }).nullable();
-var shopSourceSchema = z58.object({
-  className: z58.string().nullable().optional(),
+var shopSourceSchema = z57.object({
+  className: z57.string().nullable().optional(),
   mode: shopModeSchema.optional(),
-  heading: z58.string().nullable().optional(),
-  productSlug: z58.string().nullable().optional(),
-  showPasses: z58.boolean().optional(),
-  showMemberships: z58.boolean().optional(),
-  layout: z58.enum(["grid", "list"]).optional(),
-  columns: z58.string().optional(),
-  showDescriptions: z58.boolean().optional(),
-  showSummary: z58.boolean().optional(),
-  showBody: z58.boolean().optional(),
-  showPrices: z58.boolean().optional(),
-  showValidityPeriod: z58.boolean().optional(),
-  showPricePerCredit: z58.boolean().nullable().optional(),
-  passesHeading: z58.string().optional(),
-  membershipsHeading: z58.string().optional(),
-  buyButtonText: z58.string().optional(),
-  addButtonText: z58.string().optional(),
-  passPurchaseMode: z58.enum(["add_to_cart", "buy_now"]).optional(),
-  subscribeButtonText: z58.string().optional(),
-  emptyStateText: z58.string().optional(),
-  checkoutButtonText: z58.string().optional(),
-  clearButtonText: z58.string().optional(),
-  submitButtonText: z58.string().optional(),
+  heading: z57.string().nullable().optional(),
+  productSlug: z57.string().nullable().optional(),
+  showPasses: z57.boolean().optional(),
+  showMemberships: z57.boolean().optional(),
+  layout: z57.enum(["grid", "list"]).optional(),
+  columns: z57.string().optional(),
+  showDescriptions: z57.boolean().optional(),
+  showSummary: z57.boolean().optional(),
+  showBody: z57.boolean().optional(),
+  showPrices: z57.boolean().optional(),
+  showValidityPeriod: z57.boolean().optional(),
+  showPricePerCredit: z57.boolean().nullable().optional(),
+  passesHeading: z57.string().optional(),
+  membershipsHeading: z57.string().optional(),
+  buyButtonText: z57.string().optional(),
+  addButtonText: z57.string().optional(),
+  passPurchaseMode: z57.enum(["add_to_cart", "buy_now"]).optional(),
+  subscribeButtonText: z57.string().optional(),
+  emptyStateText: z57.string().optional(),
+  checkoutButtonText: z57.string().optional(),
+  clearButtonText: z57.string().optional(),
+  submitButtonText: z57.string().optional(),
   contentEntry: contentEntrySchema3.optional(),
-  passes: z58.array(publicPassProductSchema).nullable().optional(),
-  memberships: z58.array(publicMembershipProductSchema).nullable().optional(),
-  products: z58.array(publicProductSchema).nullable().optional(),
-  siteId: z58.string().optional(),
-  apiBaseUrl: z58.string().optional(),
+  passes: z57.array(publicPassProductSchema).nullable().optional(),
+  memberships: z57.array(publicMembershipProductSchema).nullable().optional(),
+  products: z57.array(publicProductSchema).nullable().optional(),
+  siteId: z57.string().optional(),
+  apiBaseUrl: z57.string().optional(),
   stage: previewStageSchema.optional()
 });
-var productVariantOptionDisplaySchema = z58.object({
-  id: z58.string(),
-  label: z58.string(),
-  soldOut: z58.boolean()
-});
-var productCardDisplaySchema = z58.object({
-  productId: z58.string(),
-  title: z58.string(),
-  path: z58.string().nullable(),
-  summary: z58.string().nullable(),
-  priceLabel: z58.string().nullable(),
-  image: z58.object({
-    url: z58.string(),
-    alt: z58.string().nullable()
+var productVariantOptionDisplaySchema = z57.object({
+  id: z57.string(),
+  label: z57.string(),
+  soldOut: z57.boolean()
+});
+var productCardDisplaySchema = z57.object({
+  productId: z57.string(),
+  title: z57.string(),
+  path: z57.string().nullable(),
+  summary: z57.string().nullable(),
+  priceLabel: z57.string().nullable(),
+  image: z57.object({
+    url: z57.string(),
+    alt: z57.string().nullable()
   }).nullable(),
-  variantOptions: z58.array(productVariantOptionDisplaySchema),
-  selectedVariantId: z58.string().nullable(),
-  selectionLabel: z58.string(),
-  actionLabel: z58.string(),
-  soldOut: z58.boolean()
-});
-var productListDisplaySchema = z58.object({
-  kind: z58.literal("product-list"),
-  state: z58.enum(["empty", "ready"]),
-  heading: z58.string().nullable(),
-  className: z58.string().nullable(),
-  layout: z58.enum(["grid", "list"]),
-  columns: z58.string(),
-  emptyMessage: z58.string(),
-  cards: z58.array(productCardDisplaySchema)
-});
-var productDetailDisplaySchema = z58.discriminatedUnion("state", [
-  z58.object({
-    kind: z58.literal("product-detail"),
-    state: z58.literal("empty"),
-    heading: z58.string().nullable(),
-    className: z58.string().nullable(),
-    emptyMessage: z58.string()
+  variantOptions: z57.array(productVariantOptionDisplaySchema),
+  selectedVariantId: z57.string().nullable(),
+  selectionLabel: z57.string(),
+  actionLabel: z57.string(),
+  soldOut: z57.boolean()
+});
+var productListDisplaySchema = z57.object({
+  kind: z57.literal("product-list"),
+  state: z57.enum(["empty", "ready"]),
+  heading: z57.string().nullable(),
+  className: z57.string().nullable(),
+  layout: z57.enum(["grid", "list"]),
+  columns: z57.string(),
+  emptyMessage: z57.string(),
+  cards: z57.array(productCardDisplaySchema)
+});
+var productDetailDisplaySchema = z57.discriminatedUnion("state", [
+  z57.object({
+    kind: z57.literal("product-detail"),
+    state: z57.literal("empty"),
+    heading: z57.string().nullable(),
+    className: z57.string().nullable(),
+    emptyMessage: z57.string()
   }),
-  z58.object({
-    kind: z58.literal("product-detail"),
-    state: z58.literal("ready"),
-    heading: z58.string().nullable(),
-    className: z58.string().nullable(),
-    title: z58.string(),
-    priceLabel: z58.string(),
-    summary: z58.string().nullable(),
-    categoryLabel: z58.string().nullable(),
-    gallery: z58.array(z58.object({
-      url: z58.string(),
-      alt: z58.string().nullable()
+  z57.object({
+    kind: z57.literal("product-detail"),
+    state: z57.literal("ready"),
+    heading: z57.string().nullable(),
+    className: z57.string().nullable(),
+    title: z57.string(),
+    priceLabel: z57.string(),
+    summary: z57.string().nullable(),
+    categoryLabel: z57.string().nullable(),
+    gallery: z57.array(z57.object({
+      url: z57.string(),
+      alt: z57.string().nullable()
     })),
-    variantOptions: z58.array(productVariantOptionDisplaySchema),
-    selectedVariantId: z58.string().nullable(),
-    selectionLabel: z58.string(),
-    actionLabel: z58.string(),
-    soldOut: z58.boolean(),
-    body: z58.unknown().nullable()
+    variantOptions: z57.array(productVariantOptionDisplaySchema),
+    selectedVariantId: z57.string().nullable(),
+    selectionLabel: z57.string(),
+    actionLabel: z57.string(),
+    soldOut: z57.boolean(),
+    body: z57.unknown().nullable()
   })
 ]);
-var passCardDisplaySchema = z58.object({
-  id: z58.string(),
-  title: z58.string(),
-  description: z58.string().nullable(),
-  priceLabel: z58.string(),
-  creditsLabel: z58.string(),
-  perCreditLabel: z58.string().nullable(),
-  validityLabel: z58.string().nullable(),
-  actionLabel: z58.string()
-});
-var membershipCardDisplaySchema = z58.object({
-  id: z58.string(),
-  title: z58.string(),
-  description: z58.string().nullable(),
-  priceLabel: z58.string(),
-  intervalLabel: z58.string(),
-  actionLabel: z58.string()
-});
-var passesMembershipsDisplaySchema = z58.object({
-  kind: z58.literal("passes-memberships"),
-  state: z58.enum(["empty", "ready"]),
-  className: z58.string().nullable(),
-  layout: z58.enum(["grid", "list"]),
-  columns: z58.string(),
-  emptyMessage: z58.string(),
-  passesHeading: z58.string(),
-  membershipsHeading: z58.string(),
-  passes: z58.array(passCardDisplaySchema),
-  memberships: z58.array(membershipCardDisplaySchema)
-});
-var cartLineDisplaySchema = z58.object({
-  key: z58.string(),
-  title: z58.string(),
-  priceLabel: z58.string(),
-  quantity: z58.number(),
-  quantityEditable: z58.boolean()
-});
-var cartDisplaySchema = z58.object({
-  kind: z58.literal("cart"),
-  state: z58.enum(["empty", "ready"]),
-  heading: z58.string().nullable(),
-  className: z58.string().nullable(),
-  emptyMessage: z58.string(),
-  supportText: z58.string().nullable(),
-  items: z58.array(cartLineDisplaySchema),
-  subtotalLabel: z58.string().nullable(),
-  checkoutButtonText: z58.string(),
-  clearButtonText: z58.string()
-});
-var checkoutDisplaySchema = z58.object({
-  kind: z58.literal("checkout"),
-  state: z58.enum(["empty", "blocked", "ready"]),
-  heading: z58.string().nullable(),
-  className: z58.string().nullable(),
-  message: z58.string().nullable(),
-  submitButtonText: z58.string()
-});
-var passesMembershipsHydrationSchema = z58.object({
-  passes: z58.array(publicPassProductSchema),
-  memberships: z58.array(publicMembershipProductSchema),
-  passPurchaseMode: z58.enum(["add_to_cart", "buy_now"])
-});
-var productListHydrationSchema = z58.object({
-  products: z58.array(publicProductSchema),
-  showSummary: z58.boolean(),
-  showPrices: z58.boolean(),
-  addButtonText: z58.string()
-});
-var productDetailHydrationSchema = z58.object({
-  products: z58.array(publicProductSchema),
-  productId: z58.string().nullable(),
-  showSummary: z58.boolean(),
-  showBody: z58.boolean(),
-  addButtonText: z58.string()
-});
-var cartHydrationSchema = z58.object({
-  emptyStateText: z58.string(),
-  checkoutButtonText: z58.string(),
-  clearButtonText: z58.string()
-});
-var checkoutHydrationSchema = z58.object({
-  emptyStateText: z58.string(),
-  submitButtonText: z58.string()
-});
-var passesMembershipsRenderSchema = z58.object({
+var passCardDisplaySchema = z57.object({
+  id: z57.string(),
+  title: z57.string(),
+  description: z57.string().nullable(),
+  priceLabel: z57.string(),
+  creditsLabel: z57.string(),
+  perCreditLabel: z57.string().nullable(),
+  validityLabel: z57.string().nullable(),
+  actionLabel: z57.string()
+});
+var membershipCardDisplaySchema = z57.object({
+  id: z57.string(),
+  title: z57.string(),
+  description: z57.string().nullable(),
+  priceLabel: z57.string(),
+  intervalLabel: z57.string(),
+  actionLabel: z57.string()
+});
+var passesMembershipsDisplaySchema = z57.object({
+  kind: z57.literal("passes-memberships"),
+  state: z57.enum(["empty", "ready"]),
+  className: z57.string().nullable(),
+  layout: z57.enum(["grid", "list"]),
+  columns: z57.string(),
+  emptyMessage: z57.string(),
+  passesHeading: z57.string(),
+  membershipsHeading: z57.string(),
+  passes: z57.array(passCardDisplaySchema),
+  memberships: z57.array(membershipCardDisplaySchema)
+});
+var cartLineDisplaySchema = z57.object({
+  key: z57.string(),
+  title: z57.string(),
+  priceLabel: z57.string(),
+  quantity: z57.number(),
+  quantityEditable: z57.boolean()
+});
+var cartDisplaySchema = z57.object({
+  kind: z57.literal("cart"),
+  state: z57.enum(["empty", "ready"]),
+  heading: z57.string().nullable(),
+  className: z57.string().nullable(),
+  emptyMessage: z57.string(),
+  supportText: z57.string().nullable(),
+  items: z57.array(cartLineDisplaySchema),
+  subtotalLabel: z57.string().nullable(),
+  checkoutButtonText: z57.string(),
+  clearButtonText: z57.string()
+});
+var checkoutDisplaySchema = z57.object({
+  kind: z57.literal("checkout"),
+  state: z57.enum(["empty", "blocked", "ready"]),
+  heading: z57.string().nullable(),
+  className: z57.string().nullable(),
+  message: z57.string().nullable(),
+  submitButtonText: z57.string()
+});
+var passesMembershipsHydrationSchema = z57.object({
+  passes: z57.array(publicPassProductSchema),
+  memberships: z57.array(publicMembershipProductSchema),
+  passPurchaseMode: z57.enum(["add_to_cart", "buy_now"])
+});
+var productListHydrationSchema = z57.object({
+  products: z57.array(publicProductSchema),
+  showSummary: z57.boolean(),
+  showPrices: z57.boolean(),
+  addButtonText: z57.string()
+});
+var productDetailHydrationSchema = z57.object({
+  products: z57.array(publicProductSchema),
+  productId: z57.string().nullable(),
+  showSummary: z57.boolean(),
+  showBody: z57.boolean(),
+  addButtonText: z57.string()
+});
+var cartHydrationSchema = z57.object({
+  emptyStateText: z57.string(),
+  checkoutButtonText: z57.string(),
+  clearButtonText: z57.string()
+});
+var checkoutHydrationSchema = z57.object({
+  emptyStateText: z57.string(),
+  submitButtonText: z57.string()
+});
+var passesMembershipsRenderSchema = z57.object({
   display: passesMembershipsDisplaySchema,
   hydration: passesMembershipsHydrationSchema
 });
-var productListRenderSchema = z58.object({
+var productListRenderSchema = z57.object({
   display: productListDisplaySchema,
   hydration: productListHydrationSchema
 });
-var productDetailRenderSchema = z58.object({
+var productDetailRenderSchema = z57.object({
   display: productDetailDisplaySchema,
   hydration: productDetailHydrationSchema
 });
-var cartRenderSchema = z58.object({
+var cartRenderSchema = z57.object({
   display: cartDisplaySchema,
   hydration: cartHydrationSchema
 });
-var checkoutRenderSchema = z58.object({
+var checkoutRenderSchema = z57.object({
   display: checkoutDisplaySchema,
   hydration: checkoutHydrationSchema
 });
 function resolveShowPricePerCredit(source) {
   return source.showPricePerCredit ?? true;
 }
-var shopIslandMetaCodec = createZodCodec(z58.object({
-  siteId: z58.string().optional(),
-  apiBaseUrl: z58.string().optional(),
+var shopIslandMetaCodec = createZodCodec(z57.object({
+  siteId: z57.string().optional(),
+  apiBaseUrl: z57.string().optional(),
   stage: previewStageSchema.optional()
 }));
 var shopIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl", "stage");
@@ -36310,9 +37058,9 @@ var shopBlockDefinition = {
   runtime: shopBlockRuntime,
   dataSchemas: {
     // listPublicPasses returns { passes: [...] }
-    passes: z59.object({ passes: z59.array(publicPassProductSchema) }).optional(),
+    passes: publicPassProductCollectionSchema.optional(),
     // listPublicMemberships returns { memberships: [...] }
-    memberships: z59.object({ memberships: z59.array(publicMembershipProductSchema) }).optional()
+    memberships: publicMembershipProductCollectionSchema.optional()
   },
   dataLoaders: {
     // Load passes for display
@@ -36335,7 +37083,7 @@ var shopBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/product-list.ts
-import { z as z60 } from "zod";
+import { z as z58 } from "zod";
 var productListManifest = createBlockManifest({
   id: "block.product-list",
   version: "1.0.0",
@@ -36468,7 +37216,7 @@ var productListBlockDefinition = {
     }
   }
 };
-var productListDataSchema = z60.object({
+var productListDataSchema = z58.object({
   products: publicProductsResponseSchema.optional()
 });
 
@@ -36729,72 +37477,72 @@ var checkoutBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/gifting.interactive.ts
-import { z as z61 } from "zod";
-var publicGiftCardOfferSchema = z61.object({
-  id: z61.string(),
-  kind: z61.literal("gift_card"),
-  title: z61.string(),
-  description: z61.string().nullable(),
-  sortOrder: z61.number().int(),
-  giftCard: z61.object({
-    fixedDenominations: z61.array(z61.number().int().positive()),
-    customAmountEnabled: z61.boolean(),
-    customAmountMinCents: z61.number().int().positive(),
-    customAmountMaxCents: z61.number().int().positive()
+import { z as z59 } from "zod";
+var publicGiftCardOfferSchema = z59.object({
+  id: z59.string(),
+  kind: z59.literal("gift_card"),
+  title: z59.string(),
+  description: z59.string().nullable(),
+  sortOrder: z59.number().int(),
+  giftCard: z59.object({
+    fixedDenominations: z59.array(z59.number().int().positive()),
+    customAmountEnabled: z59.boolean(),
+    customAmountMinCents: z59.number().int().positive(),
+    customAmountMaxCents: z59.number().int().positive()
   }),
-  voucher: z61.null()
-});
-var publicVoucherOfferSchema = z61.object({
-  id: z61.string(),
-  kind: z61.literal("voucher"),
-  title: z61.string(),
-  description: z61.string().nullable(),
-  sortOrder: z61.number().int(),
-  giftCard: z61.null(),
-  voucher: z61.object({
-    purchaseAmountCents: z61.number().int().positive()
+  voucher: z59.null()
+});
+var publicVoucherOfferSchema = z59.object({
+  id: z59.string(),
+  kind: z59.literal("voucher"),
+  title: z59.string(),
+  description: z59.string().nullable(),
+  sortOrder: z59.number().int(),
+  giftCard: z59.null(),
+  voucher: z59.object({
+    purchaseAmountCents: z59.number().int().positive()
   })
 });
-var publicGiftingOffersResponseSchema = z61.object({
-  currency: z61.string(),
-  giftCards: z61.array(publicGiftCardOfferSchema),
-  vouchers: z61.array(publicVoucherOfferSchema)
+var publicGiftingOffersResponseSchema = z59.object({
+  currency: z59.string(),
+  giftCards: z59.array(publicGiftCardOfferSchema),
+  vouchers: z59.array(publicVoucherOfferSchema)
 });
-var giftingSourceSchema = z61.object({
-  siteId: z61.string().optional(),
-  apiBaseUrl: z61.string().optional(),
+var giftingSourceSchema = z59.object({
+  siteId: z59.string().optional(),
+  apiBaseUrl: z59.string().optional(),
   offers: publicGiftingOffersResponseSchema.nullable().optional(),
-  className: z61.string().nullable().optional(),
-  heading: z61.string().nullable().optional(),
-  intro: z61.string().nullable().optional(),
-  giftCardsHeading: z61.string().nullable().optional(),
-  vouchersHeading: z61.string().nullable().optional(),
-  emptyStateText: z61.string().nullable().optional(),
-  checkoutButtonText: z61.string().nullable().optional(),
-  successMessage: z61.string().nullable().optional()
-});
-var giftingDisplaySchema = z61.object({
-  kind: z61.literal("gifting"),
-  state: z61.literal("ready"),
-  className: z61.string().nullable(),
-  heading: z61.string(),
-  intro: z61.string().nullable(),
-  giftCardsHeading: z61.string(),
-  vouchersHeading: z61.string(),
-  emptyStateText: z61.string()
-});
-var giftingHydrationSchema = z61.object({
+  className: z59.string().nullable().optional(),
+  heading: z59.string().nullable().optional(),
+  intro: z59.string().nullable().optional(),
+  giftCardsHeading: z59.string().nullable().optional(),
+  vouchersHeading: z59.string().nullable().optional(),
+  emptyStateText: z59.string().nullable().optional(),
+  checkoutButtonText: z59.string().nullable().optional(),
+  successMessage: z59.string().nullable().optional()
+});
+var giftingDisplaySchema = z59.object({
+  kind: z59.literal("gifting"),
+  state: z59.literal("ready"),
+  className: z59.string().nullable(),
+  heading: z59.string(),
+  intro: z59.string().nullable(),
+  giftCardsHeading: z59.string(),
+  vouchersHeading: z59.string(),
+  emptyStateText: z59.string()
+});
+var giftingHydrationSchema = z59.object({
   offers: publicGiftingOffersResponseSchema.nullable(),
-  checkoutButtonText: z61.string(),
-  successMessage: z61.string()
+  checkoutButtonText: z59.string(),
+  successMessage: z59.string()
 });
-var giftingRenderSchema = z61.object({
+var giftingRenderSchema = z59.object({
   display: giftingDisplaySchema,
   hydration: giftingHydrationSchema
 });
-var giftingIslandMetaCodec = createZodCodec(z61.object({
-  siteId: z61.string().optional(),
-  apiBaseUrl: z61.string().optional()
+var giftingIslandMetaCodec = createZodCodec(z59.object({
+  siteId: z59.string().optional(),
+  apiBaseUrl: z59.string().optional()
 }));
 var giftingIslandMetaKeys = defineInteractiveIslandMetaKeys(
   "siteId",
@@ -36965,7 +37713,7 @@ var giftingBlockDefinition = {
 };
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-import { z as z62 } from "zod";
+import { z as z60 } from "zod";
 
 // ../blocks/src/system/blocks/newsletter-signup-destination.ts
 function parseNewsletterSignupBlockId(value) {
@@ -37100,65 +37848,65 @@ function withOptionalPhone(fields3, includePhone) {
 }
 
 // ../blocks/src/system/runtime/nodes/newsletter-form.interactive.ts
-var newsletterPresetSchema = z62.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
-var newsletterDestinationProviderSchema = z62.enum(["riverbank", "mailchimp"]);
-var newsletterFieldSchema = z62.object({
-  id: z62.string(),
-  type: z62.enum(["email", "text"]),
-  label: z62.string(),
-  required: z62.boolean(),
-  placeholder: z62.string().optional()
-});
-var newsletterSignupBlockIdSchema = z62.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
-var signedNewsletterDestinationRefSchema = z62.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
-var newsletterPublicDestinationRefSchema = z62.discriminatedUnion("tag", [
-  z62.object({
-    tag: z62.literal("block_ref"),
+var newsletterPresetSchema = z60.enum(["emailOnly", "emailName", "emailFirstLast", "emailNameCompany"]);
+var newsletterDestinationProviderSchema = z60.enum(["riverbank", "mailchimp"]);
+var newsletterFieldSchema = z60.object({
+  id: z60.string(),
+  type: z60.enum(["email", "text"]),
+  label: z60.string(),
+  required: z60.boolean(),
+  placeholder: z60.string().optional()
+});
+var newsletterSignupBlockIdSchema = z60.string().trim().min(1).transform(parseRequiredNewsletterSignupBlockId);
+var signedNewsletterDestinationRefSchema = z60.string().trim().min(1).transform(parseRequiredSignedNewsletterDestinationRef);
+var newsletterPublicDestinationRefSchema = z60.discriminatedUnion("tag", [
+  z60.object({
+    tag: z60.literal("block_ref"),
     blockId: newsletterSignupBlockIdSchema
   }),
-  z62.object({
-    tag: z62.literal("signed_destination_ref"),
+  z60.object({
+    tag: z60.literal("signed_destination_ref"),
     token: signedNewsletterDestinationRefSchema
   })
 ]);
-var newsletterSourceSchema = z62.object({
-  blockId: z62.string().nullable().optional(),
-  siteId: z62.string().optional(),
-  apiBaseUrl: z62.string().optional(),
-  listId: z62.string().nullable().optional(),
+var newsletterSourceSchema = z60.object({
+  blockId: z60.string().nullable().optional(),
+  siteId: z60.string().optional(),
+  apiBaseUrl: z60.string().optional(),
+  listId: z60.string().nullable().optional(),
   destinationProvider: newsletterDestinationProviderSchema.nullable().optional(),
   preset: newsletterPresetSchema.optional(),
-  includePhone: z62.boolean().optional(),
-  buttonLabel: z62.string().nullable().optional(),
-  successMessage: z62.string().nullable().optional(),
-  privacyNote: z62.string().nullable().optional(),
-  tags: z62.string().nullable().optional(),
-  spamProtectionEnabled: z62.boolean().optional(),
-  className: z62.string().nullable().optional()
-});
-var newsletterDisplaySchema = z62.object({
-  kind: z62.literal("newsletter-form"),
-  className: z62.string().nullable(),
-  buttonLabel: z62.string(),
-  successMessage: z62.string().nullable(),
-  privacyNote: z62.string().nullable(),
-  fields: z62.array(newsletterFieldSchema)
-});
-var newsletterHydrationSchema = z62.object({
+  includePhone: z60.boolean().optional(),
+  buttonLabel: z60.string().nullable().optional(),
+  successMessage: z60.string().nullable().optional(),
+  privacyNote: z60.string().nullable().optional(),
+  tags: z60.string().nullable().optional(),
+  spamProtectionEnabled: z60.boolean().optional(),
+  className: z60.string().nullable().optional()
+});
+var newsletterDisplaySchema = z60.object({
+  kind: z60.literal("newsletter-form"),
+  className: z60.string().nullable(),
+  buttonLabel: z60.string(),
+  successMessage: z60.string().nullable(),
+  privacyNote: z60.string().nullable(),
+  fields: z60.array(newsletterFieldSchema)
+});
+var newsletterHydrationSchema = z60.object({
   destinationRef: newsletterPublicDestinationRefSchema.nullable().optional(),
-  listId: z62.string().nullable().optional(),
+  listId: z60.string().nullable().optional(),
   preset: newsletterPresetSchema,
-  includePhone: z62.boolean(),
-  tags: z62.string().nullable().optional(),
-  spamProtectionEnabled: z62.boolean().optional()
+  includePhone: z60.boolean(),
+  tags: z60.string().nullable().optional(),
+  spamProtectionEnabled: z60.boolean().optional()
 });
-var newsletterRenderSchema = z62.object({
+var newsletterRenderSchema = z60.object({
   display: newsletterDisplaySchema,
   hydration: newsletterHydrationSchema
 });
-var newsletterIslandMetaCodec = createZodCodec(z62.object({
-  siteId: z62.string().optional(),
-  apiBaseUrl: z62.string().optional()
+var newsletterIslandMetaCodec = createZodCodec(z60.object({
+  siteId: z60.string().optional(),
+  apiBaseUrl: z60.string().optional()
 }));
 var newsletterIslandMetaKeys = defineInteractiveIslandMetaKeys("siteId", "apiBaseUrl");
 function buildNewsletterDisplay(source) {
@@ -37297,23 +38045,23 @@ var newsletterSignupBlockDefinition = {
 };
 
 // ../blocks/src/system/blocks/team-members.ts
-import { z as z63 } from "zod";
+import { z as z61 } from "zod";
 var ITEM_NAME2 = "member";
 var teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
   message: "Team member photos must be image media"
 }).nullable();
-var teamMemberDataSchema = z63.object({
-  _type: z63.literal("teamMember"),
-  id: z63.string(),
-  name: z63.string(),
-  role: z63.string().nullable(),
-  roleLabel: z63.string().nullable(),
-  bio: z63.string().nullable(),
-  summary: z63.string().nullable(),
+var teamMemberDataSchema = z61.object({
+  _type: z61.literal("teamMember"),
+  id: z61.string(),
+  name: z61.string(),
+  role: z61.string().nullable(),
+  roleLabel: z61.string().nullable(),
+  bio: z61.string().nullable(),
+  summary: z61.string().nullable(),
   photo: teamMemberPhotoSchema,
-  profilePath: z63.string().nullable()
+  profilePath: z61.string().nullable()
 });
-var teamMembersDataSchema = z63.array(teamMemberDataSchema);
+var teamMembersDataSchema = z61.array(teamMemberDataSchema);
 var dynamicSourceWhen = { equals: "site_staff" };
 var manualSourceWhen = { equals: "site_staff", not: true };
 var headingNode = text(
@@ -38205,13 +38953,6 @@ var systemBlockDefinitionsRaw = [
         weight: "featured",
         bias: "clear",
         surfaces: heroSectionSurfaces
-      }),
-      layoutProfile({
-        variantKey: "splitEditorial",
-        family: "split",
-        weight: "featured",
-        bias: "clear",
-        surfaces: heroSectionSurfaces
       })
     ]
   })),
@@ -38455,9 +39196,8 @@ var systemBlockDefinitionsRaw = [
     flow: offeringsFlow,
     layoutProfiles: [
       layoutProfile({ variantKey: "combined", family: "grid", weight: "standard" }),
+      layoutProfile({ variantKey: "calendar", family: "stack", weight: "standard" }),
       layoutProfile({ variantKey: "list", family: "stack", weight: "standard" }),
-      layoutProfile({ variantKey: "month", family: "grid", weight: "standard" }),
-      layoutProfile({ variantKey: "week", family: "stack", weight: "standard" }),
       layoutProfile({ variantKey: "timetable", family: "stack", weight: "standard" })
     ]
   })),
@@ -39020,10 +39760,7 @@ function normalizeRenderStage(stage) {
   return stage === "preview" ? "preview" : "published";
 }
 function isRouteVisibleInStage(routeEntry, stageInput) {
-  const stage = normalizeRenderStage(stageInput);
-  if (stage === "preview" || !isRouteRecord(routeEntry)) {
-    return true;
-  }
+  if (normalizeRenderStage(stageInput) === "preview" || !isRouteRecord(routeEntry)) return true;
   const status = routeEntry.status;
   return !(typeof status === "string" && status !== "published");
 }
@@ -39032,52 +39769,45 @@ function extractRouteHref(candidate, stageInput = "published") {
     const trimmed = candidate.trim();
     return trimmed.length > 0 ? trimmed : null;
   }
-  if (!isRouteRecord(candidate)) {
-    return null;
-  }
-  const stage = normalizeRenderStage(stageInput);
-  const fields3 = stage === "preview" ? ["draftPath", "path", "href", "url"] : ["path", "href", "url"];
+  if (!isRouteRecord(candidate)) return null;
+  const fields3 = normalizeRenderStage(stageInput) === "preview" ? [
+    "draftPath",
+    "path",
+    "href",
+    "url"
+  ] : [
+    "path",
+    "href",
+    "url"
+  ];
   for (const field of fields3) {
     const value = candidate[field];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return value.trim();
-    }
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
   }
   return null;
 }
 function extractRouteUpdatedAt(candidate) {
-  if (!isRouteRecord(candidate)) {
-    return null;
-  }
-  const fields3 = [
+  if (!isRouteRecord(candidate)) return null;
+  for (const field of [
     "updatedAt",
     "updated_at",
     "publishedAt",
     "published_at",
     "modifiedAt",
     "modified_at"
-  ];
-  for (const field of fields3) {
+  ]) {
     const value = candidate[field];
-    if (typeof value === "string" && value.length > 0) {
-      return value;
-    }
+    if (typeof value === "string" && value.length > 0) return value;
   }
   return null;
 }
 function resolveRouteTargetForStage(routeIdValue, routes, stageInput) {
   const routeId = typeof routeIdValue === "string" ? routeIdValue : null;
-  if (!routeId || !routes) {
-    return null;
-  }
+  if (!routeId || !routes) return null;
   const routeEntry = routes[routeId];
-  if (!isRouteVisibleInStage(routeEntry, stageInput)) {
-    return null;
-  }
+  if (!isRouteVisibleInStage(routeEntry, stageInput)) return null;
   const href = extractRouteHref(routeEntry, stageInput);
-  if (!href) {
-    return null;
-  }
+  if (!href) return null;
   return {
     routeId,
     href,
@@ -39315,7 +40045,7 @@ function resolveLinkedContentEditSupport(contentType) {
     case "unsupported-domain-backed":
       return { kind: "unsupported-domain-backed", reason: metadata.reason };
     default:
-      return assertNever(metadata);
+      return assertNever2(metadata);
   }
 }
 function contentTypeKeyToLabel(key) {
@@ -40113,42 +40843,45 @@ 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/ResponsiveScope.tsx
+import { jsx as jsx7, jsxs as jsxs5 } 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 z64 } from "zod";
-var themeBridgeConfigSchema = z64.object({
-  tokens: z64.record(z64.string(), z64.string()),
-  typography: z64.object({
-    headingFamily: z64.string().optional(),
-    bodyFamily: z64.string().optional(),
-    headingWeight: z64.number().optional(),
-    bodyWeight: z64.number().optional()
+import { z as z62 } from "zod";
+var themeBridgeConfigSchema = z62.object({
+  tokens: z62.record(z62.string(), z62.string()),
+  typography: z62.object({
+    headingFamily: z62.string().optional(),
+    bodyFamily: z62.string().optional(),
+    headingWeight: z62.number().optional(),
+    bodyWeight: z62.number().optional()
   }).optional(),
-  spacing: z64.enum(["comfortable", "standard", "dense"]).optional(),
-  corners: z64.enum(["square", "soft", "rounded", "pill"]).optional(),
-  shadows: z64.enum(["none", "low", "medium", "high"]).optional(),
-  components: z64.object({
-    buttons: z64.union([
-      z64.boolean(),
-      z64.object({
-        variants: z64.array(z64.enum(["primary", "secondary", "outline", "ghost"])).optional()
+  spacing: z62.enum(["comfortable", "standard", "dense"]).optional(),
+  corners: z62.enum(["square", "soft", "rounded", "pill"]).optional(),
+  shadows: z62.enum(["none", "low", "medium", "high"]).optional(),
+  components: z62.object({
+    buttons: z62.union([
+      z62.boolean(),
+      z62.object({
+        variants: z62.array(z62.enum(["primary", "secondary", "outline", "ghost"])).optional()
       })
     ]).optional(),
-    cards: z64.union([
-      z64.boolean(),
-      z64.object({
-        variants: z64.array(z64.enum(["default", "elevated", "outlined"])).optional()
+    cards: z62.union([
+      z62.boolean(),
+      z62.object({
+        variants: z62.array(z62.enum(["default", "elevated", "outlined"])).optional()
       })
     ]).optional(),
-    inputs: z64.boolean().optional()
+    inputs: z62.boolean().optional()
   }).optional(),
-  overrides: z64.record(z64.string(), z64.string()).optional()
+  overrides: z62.record(z62.string(), z62.string()).optional()
 }).passthrough();
 
 // ../theme-core/src/siteChrome.tsx
-import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 
 // ../blocks/src/system/runtime/bindings.ts
 var shouldLogWarnings = isNonProductionEnv();
@@ -40513,17 +41246,17 @@ function normalizeLoaderParams(endpoint, params, context) {
 function unsafeRetypeZodSchema(schema) {
   return schema;
 }
-var navIdListSchema = z65.preprocess((value) => {
+var navIdListSchema = z63.preprocess((value) => {
   if (!Array.isArray(value)) return void 0;
   const filtered = value.filter((v) => typeof v === "string" && v.trim().length > 0);
   return filtered.length > 0 ? filtered : void 0;
-}, z65.array(z65.string()).max(200).optional());
-var dashboardNavVisibilityBaseSchema = z65.object({
-  mode: z65.enum(["augment", "restrict"]).optional(),
+}, z63.array(z63.string()).max(200).optional());
+var dashboardNavVisibilityBaseSchema = z63.object({
+  mode: z63.enum(["augment", "restrict"]).optional(),
   allowIds: navIdListSchema,
   denyIds: navIdListSchema
 }).strip();
-var dashboardNavVisibilityRolesSchema = z65.object({
+var dashboardNavVisibilityRolesSchema = z63.object({
   administrator: dashboardNavVisibilityBaseSchema.optional(),
   editor: dashboardNavVisibilityBaseSchema.optional(),
   team_member: dashboardNavVisibilityBaseSchema.optional()
@@ -40531,63 +41264,63 @@ var dashboardNavVisibilityRolesSchema = z65.object({
 var dashboardNavVisibilitySchema = dashboardNavVisibilityBaseSchema.extend({
   roles: dashboardNavVisibilityRolesSchema
 }).strip();
-var dashboardNavigationConfigSchema = z65.object({
+var dashboardNavigationConfigSchema = z63.object({
   siteNav: dashboardNavVisibilitySchema.optional(),
   settingsNav: dashboardNavVisibilitySchema.optional()
 }).strip();
-var dashboardConfigSchema = z65.object({
-  previewEditingEnabled: z65.boolean().optional(),
+var dashboardConfigSchema = z63.object({
+  previewEditingEnabled: z63.boolean().optional(),
   navigation: dashboardNavigationConfigSchema.optional()
 }).strip();
 var fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
 var nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
-var sdkLoaderEndpointSchema = z65.enum(SUPPORTED_LOADER_ENDPOINTS);
-var loaderFallbackScalarSchema = z65.union([
-  z65.string(),
-  z65.number(),
-  z65.boolean(),
-  z65.null()
+var sdkLoaderEndpointSchema = z63.enum(SUPPORTED_LOADER_ENDPOINTS);
+var loaderFallbackScalarSchema = z63.union([
+  z63.string(),
+  z63.number(),
+  z63.boolean(),
+  z63.null()
 ]);
-var loaderParamBindingSchema = z65.object({
-  $bind: z65.object({
-    from: z65.string().min(1, "Binding path is required"),
+var loaderParamBindingSchema = z63.object({
+  $bind: z63.object({
+    from: z63.string().min(1, "Binding path is required"),
     fallback: loaderFallbackScalarSchema.optional()
   })
 });
-var loaderParamValueSchema = z65.union([
-  z65.string(),
-  z65.number(),
-  z65.boolean(),
+var loaderParamValueSchema = z63.union([
+  z63.string(),
+  z63.number(),
+  z63.boolean(),
   loaderParamBindingSchema
 ]);
-var sdkConfigLoaderSchema = z65.object({
+var sdkConfigLoaderSchema = z63.object({
   endpoint: sdkLoaderEndpointSchema,
-  params: z65.record(z65.string(), loaderParamValueSchema),
-  mode: z65.enum(["server", "client"]).default("server")
+  params: z63.record(z63.string(), loaderParamValueSchema),
+  mode: z63.enum(["server", "client"]).default("server")
 });
-var sdkDataLoadersSchema = z65.record(z65.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
-var sdkCustomBlockIdSchema = z65.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+var sdkDataLoadersSchema = z63.record(z63.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
+var sdkCustomBlockIdSchema = z63.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
   message: "Block ID must start with 'custom.' followed by lowercase letters, numbers, or hyphens"
 }).transform((value) => value);
-var sdkCustomBlockInputSchema = z65.object({
+var sdkCustomBlockInputSchema = z63.object({
   id: sdkCustomBlockIdSchema,
-  title: z65.string().min(1),
-  titleSource: z65.union([z65.string().min(1), z65.array(z65.string().min(1)).min(1)]).optional(),
-  description: z65.string().optional(),
+  title: z63.string().min(1),
+  titleSource: z63.union([z63.string().min(1), z63.array(z63.string().min(1)).min(1)]).optional(),
+  description: z63.string().optional(),
   category: blockCategoryEnum,
-  icon: z65.string().optional(),
-  tags: z65.array(z65.string()).optional(),
+  icon: z63.string().optional(),
+  tags: z63.array(z63.string()).optional(),
   fields: fieldDefinitionInputSchema.array().min(1),
   dataLoaders: sdkDataLoadersSchema,
   layout: NodeSchema.optional(),
-  variants: z65.record(z65.string().min(1), NodeSchema).optional(),
-  defaultVariant: z65.string().min(1).optional(),
-  variantOptions: z65.record(
-    z65.string().min(1),
-    z65.object({
-      label: z65.string().min(1).optional(),
-      description: z65.string().min(1).optional(),
-      icon: z65.string().min(1).optional()
+  variants: z63.record(z63.string().min(1), NodeSchema).optional(),
+  defaultVariant: z63.string().min(1).optional(),
+  variantOptions: z63.record(
+    z63.string().min(1),
+    z63.object({
+      label: z63.string().min(1).optional(),
+      description: z63.string().min(1).optional(),
+      icon: z63.string().min(1).optional()
     })
   ).optional(),
   previewCustomize: previewCustomizeManifestCurationSchema.optional()
@@ -40598,7 +41331,7 @@ var sdkCustomBlockInputSchema = z65.object({
       const exists = data.fields.some((field) => field.id === source);
       if (!exists) {
         ctx.addIssue({
-          code: z65.ZodIssueCode.custom,
+          code: z63.ZodIssueCode.custom,
           message: `titleSource must reference a valid field ID (got "${source}")`,
           path: Array.isArray(data.titleSource) ? ["titleSource", index] : ["titleSource"]
         });
@@ -40607,7 +41340,7 @@ var sdkCustomBlockInputSchema = z65.object({
   }
   if (data.layout && data.variants) {
     ctx.addIssue({
-      code: z65.ZodIssueCode.custom,
+      code: z63.ZodIssueCode.custom,
       message: "Custom block must define either `layout` or `variants`, not both",
       path: ["variants"]
     });
@@ -40616,14 +41349,14 @@ var sdkCustomBlockInputSchema = z65.object({
     const keys = Object.keys(data.variants);
     if (keys.length === 0) {
       ctx.addIssue({
-        code: z65.ZodIssueCode.custom,
+        code: z63.ZodIssueCode.custom,
         message: "`variants` must contain at least one variant key",
         path: ["variants"]
       });
     }
     if (data.defaultVariant && !Object.prototype.hasOwnProperty.call(data.variants, data.defaultVariant)) {
       ctx.addIssue({
-        code: z65.ZodIssueCode.custom,
+        code: z63.ZodIssueCode.custom,
         message: "`defaultVariant` must be a key present in `variants`",
         path: ["defaultVariant"]
       });
@@ -40632,7 +41365,7 @@ var sdkCustomBlockInputSchema = z65.object({
       for (const key of Object.keys(data.variantOptions)) {
         if (!Object.prototype.hasOwnProperty.call(data.variants, key)) {
           ctx.addIssue({
-            code: z65.ZodIssueCode.custom,
+            code: z63.ZodIssueCode.custom,
             message: "`variantOptions` key must exist in `variants`",
             path: ["variantOptions", key]
           });
@@ -40641,78 +41374,78 @@ var sdkCustomBlockInputSchema = z65.object({
     }
   }
 });
-var sdkBlockFieldExtensionInputSchema = z65.object({
+var sdkBlockFieldExtensionInputSchema = z63.object({
   fields: fieldDefinitionInputSchema.array().min(1)
 });
-var sdkBlockFieldExtensionsInputSchema = z65.record(
-  z65.string().min(1),
+var sdkBlockFieldExtensionsInputSchema = z63.record(
+  z63.string().min(1),
   sdkBlockFieldExtensionInputSchema
 );
-var sdkThemePaletteSchema = z65.record(z65.string(), z65.string());
-var sdkThemeConfigSchema = z65.object({
+var sdkThemePaletteSchema = z63.record(z63.string(), z63.string());
+var sdkThemeConfigSchema = z63.object({
   palette: sdkThemePaletteSchema
 });
-var sdkSectionBackgroundSchema = z65.object({
-  id: z65.string().min(1),
-  label: z65.string().min(1),
-  token: z65.string().min(1)
+var sdkSectionBackgroundSchema = z63.object({
+  id: z63.string().min(1),
+  label: z63.string().min(1),
+  token: z63.string().min(1)
 });
-var sdkSectionOptionsConfigSchema = z65.object({
-  backgroundColor: z65.boolean().optional(),
-  backgroundImage: z65.boolean().optional(),
-  backgroundGradient: z65.boolean().optional(),
-  spacing: z65.union([z65.array(z65.enum(["compact", "default", "spacious"])), z65.boolean()]).optional(),
-  textColor: z65.boolean().optional()
+var sdkSectionOptionsConfigSchema = z63.object({
+  backgroundColor: z63.boolean().optional(),
+  backgroundImage: z63.boolean().optional(),
+  backgroundGradient: z63.boolean().optional(),
+  spacing: z63.union([z63.array(z63.enum(["compact", "default", "spacious"])), z63.boolean()]).optional(),
+  textColor: z63.boolean().optional()
 });
-var sdkContainerOptionsConfigSchema = z65.object({
-  maxWidth: z65.union([z65.array(z65.enum(["narrow", "default", "wide", "full"])), z65.boolean()]).optional(),
-  alignment: z65.union([z65.array(z65.enum(["left", "center", "right"])), z65.boolean()]).optional()
+var sdkContainerOptionsConfigSchema = z63.object({
+  maxWidth: z63.union([z63.array(z63.enum(["narrow", "default", "wide", "full"])), z63.boolean()]).optional(),
+  alignment: z63.union([z63.array(z63.enum(["left", "center", "right"])), z63.boolean()]).optional()
 });
-var sdkSiteStyleConfigSchema = z65.object({
-  sectionBackgrounds: z65.array(sdkSectionBackgroundSchema).optional(),
+var sdkSiteStyleConfigSchema = z63.object({
+  sectionBackgrounds: z63.array(sdkSectionBackgroundSchema).optional(),
   sectionOptions: sdkSectionOptionsConfigSchema.optional(),
   containerOptions: sdkContainerOptionsConfigSchema.optional()
 });
-var sdkSiteLayoutConfigSchema = z65.object({
-  footerBlocks: z65.array(
-    z65.object({
-      id: z65.string().min(1).optional(),
-      kind: z65.string().min(1),
-      content: z65.record(z65.string(), z65.unknown()).optional()
+var sdkSiteLayoutConfigSchema = z63.object({
+  footerBlocks: z63.array(
+    z63.object({
+      id: z63.string().min(1).optional(),
+      kind: z63.string().min(1),
+      content: z63.record(z63.string(), z63.unknown()).optional()
     })
   ).optional()
 });
-var sdkFieldSelectOptionSchema = z65.object({
-  value: z65.string(),
-  label: z65.string()
+var sdkFieldSelectOptionSchema = z63.object({
+  value: z63.string(),
+  label: z63.string()
 });
-var sdkBlockFieldConfigSchema = z65.object({
-  options: z65.array(sdkFieldSelectOptionSchema).optional()
+var sdkBlockFieldConfigSchema = z63.object({
+  options: z63.array(sdkFieldSelectOptionSchema).optional()
 });
-var sdkBlockFieldOptionsMapSchema = z65.record(
-  z65.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
+var sdkBlockFieldOptionsMapSchema = z63.record(
+  z63.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
     message: "Block ID must be 'block.*' or 'custom.*' format"
   }),
-  z65.record(z65.string().min(1), sdkBlockFieldConfigSchema)
+  z63.record(z63.string().min(1), sdkBlockFieldConfigSchema)
 ).optional();
-var sdkContentTypeTemplateConfigSchema = z65.object({
-  blocks: z65.array(z65.unknown())
+var sdkContentTypeTemplateConfigSchema = z63.object({
+  blocks: z63.array(z63.unknown())
 }).passthrough();
-var sdkContentTypeOrderingConfigSchema = z65.object({
-  mode: z65.enum(["default", "manual"]).optional()
+var sdkContentTypeOrderingConfigSchema = z63.object({
+  mode: z63.enum(["default", "manual"]).optional()
 }).optional();
-var sdkContentTypeConfigSchema = z65.object({
-  key: z65.string().min(1),
-  fields: z65.array(z65.unknown()),
+var sdkContentTypeConfigSchema = z63.object({
+  key: z63.string().min(1),
+  fields: z63.array(z63.unknown()),
   ordering: sdkContentTypeOrderingConfigSchema,
   template: sdkContentTypeTemplateConfigSchema.nullable().optional()
 }).passthrough();
-var sdkContentConfigSchema = z65.object({
-  contentTypes: z65.array(sdkContentTypeConfigSchema).optional(),
-  pages: z65.array(z65.unknown()).optional(),
-  entries: z65.array(z65.unknown()).optional(),
-  navigationMenus: z65.array(z65.unknown()).optional(),
-  settings: z65.unknown().optional()
+var sdkContentConfigSchema = z63.object({
+  contentTypes: z63.array(sdkContentTypeConfigSchema).optional(),
+  pages: z63.array(z63.unknown()).optional(),
+  entries: z63.array(z63.unknown()).optional(),
+  navigationMenus: z63.array(z63.unknown()).optional(),
+  settings: z63.unknown().optional()
 }).passthrough();
 var SDK_WORKFLOW_ID_MAX_LENGTH = 120;
 var SDK_WORKFLOW_TITLE_MAX_LENGTH = 120;
@@ -40727,62 +41460,62 @@ var SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH = 120;
 var SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH = 500;
 var SDK_WORKFLOW_ID_PATTERN = /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/;
 var SDK_WORKFLOW_ENDPOINT_PATTERN = /^\//;
-var sdkWorkflowIdSchema = z65.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
+var sdkWorkflowIdSchema = z63.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
   message: "Workflow ID must start with a lowercase letter and use lowercase letters, numbers, dots, underscores, or hyphens"
 });
-var sdkWorkflowEndpointSchema = z65.string().min(1).max(SDK_WORKFLOW_ENDPOINT_MAX_LENGTH).regex(SDK_WORKFLOW_ENDPOINT_PATTERN, { message: 'Workflow endpoint must be a site-relative path starting with "/"' });
-var sdkWorkflowManualTriggerSchema = z65.object({
-  type: z65.literal("manual")
+var sdkWorkflowEndpointSchema = z63.string().min(1).max(SDK_WORKFLOW_ENDPOINT_MAX_LENGTH).regex(SDK_WORKFLOW_ENDPOINT_PATTERN, { message: 'Workflow endpoint must be a site-relative path starting with "/"' });
+var sdkWorkflowManualTriggerSchema = z63.object({
+  type: z63.literal("manual")
 }).strict();
-var sdkWorkflowTriggerFieldSchema = z65.string().trim().min(1).max(SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH).refine((field) => !field.includes("."), {
+var sdkWorkflowTriggerFieldSchema = z63.string().trim().min(1).max(SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH).refine((field) => !field.includes("."), {
   message: "Workflow trigger fields must be top-level content field IDs, not paths"
 });
-var sdkWorkflowFieldChangedConditionSchema = z65.object({
+var sdkWorkflowFieldChangedConditionSchema = z63.object({
   field: sdkWorkflowTriggerFieldSchema,
-  changed: z65.literal(true)
+  changed: z63.literal(true)
 }).strict();
-var sdkWorkflowFieldEmptyConditionSchema = z65.object({
+var sdkWorkflowFieldEmptyConditionSchema = z63.object({
   field: sdkWorkflowTriggerFieldSchema,
-  isEmpty: z65.boolean()
+  isEmpty: z63.boolean()
 }).strict();
-var sdkWorkflowEntryDraftUpdatedTriggerSchema = z65.object({
-  type: z65.literal("entry.draft.updated"),
-  when: z65.array(
-    z65.union([
+var sdkWorkflowEntryDraftUpdatedTriggerSchema = z63.object({
+  type: z63.literal("entry.draft.updated"),
+  when: z63.array(
+    z63.union([
       sdkWorkflowFieldChangedConditionSchema,
       sdkWorkflowFieldEmptyConditionSchema
     ])
   ).min(1).max(SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT)
 }).strict();
-var sdkWorkflowTriggerSchema = z65.discriminatedUnion("type", [
+var sdkWorkflowTriggerSchema = z63.discriminatedUnion("type", [
   sdkWorkflowManualTriggerSchema,
   sdkWorkflowEntryDraftUpdatedTriggerSchema
 ]);
-var sdkWorkflowConfirmationSchema = z65.object({
-  title: z65.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
-  body: z65.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
+var sdkWorkflowConfirmationSchema = z63.object({
+  title: z63.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
+  body: z63.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
 }).strict();
-var sdkWorkflowConfigSchema = z65.object({
+var sdkWorkflowConfigSchema = z63.object({
   id: sdkWorkflowIdSchema,
-  title: z65.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
-  description: z65.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
-  contentType: z65.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
+  title: z63.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
+  description: z63.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
+  contentType: z63.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
   endpoint: sdkWorkflowEndpointSchema,
-  triggers: z65.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
+  triggers: z63.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
   confirmation: sdkWorkflowConfirmationSchema.optional()
 }).strict();
-var sdkWorkflowsSchema = z65.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
+var sdkWorkflowsSchema = z63.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
   const ids = workflows.map((workflow) => workflow.id);
   return ids.length === new Set(ids).size;
 }, { message: "Workflow IDs must be unique" }).optional();
-var riverbankSiteConfigInputSchema = z65.object({
-  siteId: z65.string().uuid(),
-  previewUrl: z65.string().url().optional(),
-  liveUrl: z65.string().url().optional(),
+var riverbankSiteConfigInputSchema = z63.object({
+  siteId: z63.string().uuid(),
+  previewUrl: z63.string().url().optional(),
+  liveUrl: z63.string().url().optional(),
   theme: sdkThemeConfigSchema.optional(),
   styles: sdkSiteStyleConfigSchema.optional(),
   layout: sdkSiteLayoutConfigSchema.optional(),
-  customBlocks: z65.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
+  customBlocks: z63.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
     const ids = blocks.map((b) => b.id);
     return ids.length === new Set(ids).size;
   }, { message: "Block IDs must be unique" }).optional(),
@@ -40790,50 +41523,50 @@ var riverbankSiteConfigInputSchema = z65.object({
   blockFieldExtensions: sdkBlockFieldExtensionsInputSchema.optional(),
   workflows: sdkWorkflowsSchema,
   content: sdkContentConfigSchema.optional(),
-  contentDir: z65.string().optional(),
-  sync: z65.object({
-    existingEntries: z65.enum(["skip", "update"]).optional()
+  contentDir: z63.string().optional(),
+  sync: z63.object({
+    existingEntries: z63.enum(["skip", "update"]).optional()
   }).optional(),
-  deploy: z65.object({
-    verifyCommand: z65.string().optional(),
-    prebuildOutput: z65.string().optional()
+  deploy: z63.object({
+    verifyCommand: z63.string().optional(),
+    prebuildOutput: z63.string().optional()
   }).optional(),
-  themeSource: z65.enum(["local", "cms"]).optional(),
-  activeTheme: z65.string().optional(),
-  enablePortal: z65.boolean().optional(),
+  themeSource: z63.enum(["local", "cms"]).optional(),
+  activeTheme: z63.string().optional(),
+  enablePortal: z63.boolean().optional(),
   dashboard: dashboardConfigSchema.optional()
 }).strict();
-var pushSdkConfigBodySchema = z65.object({
+var pushSdkConfigBodySchema = z63.object({
   config: riverbankSiteConfigInputSchema,
-  forceContentTypes: z65.boolean().optional()
+  forceContentTypes: z63.boolean().optional()
 }).strict();
 
 // ../api/src/siteOnboarding.ts
-import { z as z66 } from "zod";
+import { z as z64 } from "zod";
 var LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS = {
   configure_appointments: {
     requirementId: "configure_appointments",
     reason: "launch_anyway"
   }
 };
-var acknowledgeLaunchRequirementRequestSchema = z66.discriminatedUnion(
+var acknowledgeLaunchRequirementRequestSchema = z64.discriminatedUnion(
   "requirementId",
   [
-    z66.object({
-      requirementId: z66.literal("review_generated_site")
+    z64.object({
+      requirementId: z64.literal("review_generated_site")
     }),
-    z66.object({
-      requirementId: z66.literal(
+    z64.object({
+      requirementId: z64.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.requirementId
       ),
-      overrideReason: z66.literal(
+      overrideReason: z64.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.reason
       )
     })
   ]
 );
-var goLiveSiteRequestSchema = z66.object({
-  acceptExtraSiteCharge: z66.boolean().optional()
+var goLiveSiteRequestSchema = z64.object({
+  acceptExtraSiteCharge: z64.boolean().optional()
 });
 
 // ../api/src/customerMembershipOutcomes.ts
@@ -40910,7 +41643,7 @@ var COURSE_ENROLLMENT_REFUND_FAILED_CODES = [
 ];
 
 // ../api/src/bookingVerticals.ts
-import { z as z67 } from "zod";
+import { z as z65 } from "zod";
 var VERTICAL_IDS = [
   "yoga_wellness",
   "fitness_pt",
@@ -41075,39 +41808,39 @@ function getSiteVerticalConfigIssues(rawConfig, config) {
   }
   return [...issues];
 }
-var VerticalIdSchema = z67.string().trim().transform((value, ctx) => {
+var VerticalIdSchema = z65.string().trim().transform((value, ctx) => {
   const parsed = parseVerticalId(value);
   if (!parsed) {
     ctx.addIssue({
-      code: z67.ZodIssueCode.custom,
+      code: z65.ZodIssueCode.custom,
       message: "Unknown booking vertical"
     });
-    return z67.NEVER;
+    return z65.NEVER;
   }
   return parsed;
 });
-var VerticalPresetIdSchema = z67.string().trim().transform((value, ctx) => {
+var VerticalPresetIdSchema = z65.string().trim().transform((value, ctx) => {
   const parsed = parseVerticalPresetId(value);
   if (!parsed) {
     ctx.addIssue({
-      code: z67.ZodIssueCode.custom,
+      code: z65.ZodIssueCode.custom,
       message: "Unknown booking preset"
     });
-    return z67.NEVER;
+    return z65.NEVER;
   }
   return parsed;
 });
-var BookingVerticalConfigSchema = z67.object({
+var BookingVerticalConfigSchema = z65.object({
   verticalId: VerticalIdSchema.nullable(),
-  selectedPresetIds: z67.array(VerticalPresetIdSchema).max(20)
+  selectedPresetIds: z65.array(VerticalPresetIdSchema).max(20)
 }).transform((value, ctx) => {
   const resolved = resolveSiteVerticalBookingConfig(value);
   if (resolved.kind === "invalid") {
     ctx.addIssue({
-      code: z67.ZodIssueCode.custom,
+      code: z65.ZodIssueCode.custom,
       message: `Invalid booking vertical config: ${resolved.issues.join(", ")}`
     });
-    return z67.NEVER;
+    return z65.NEVER;
   }
   return resolved.config;
 });
@@ -41134,51 +41867,51 @@ function isRecord9(value) {
 }
 
 // ../api/src/appointmentSetup.ts
-import { z as z68 } from "zod";
+import { z as z66 } from "zod";
 var APPOINTMENT_SETUP_MAX_MINUTES = 1440;
-var appointmentSetupRefSchema = z68.discriminatedUnion("kind", [
-  z68.object({ kind: z68.literal("existing"), id: z68.string().min(1) }),
-  z68.object({ kind: z68.literal("new"), draftId: z68.string().min(1) })
+var appointmentSetupRefSchema = z66.discriminatedUnion("kind", [
+  z66.object({ kind: z66.literal("existing"), id: z66.string().min(1) }),
+  z66.object({ kind: z66.literal("new"), draftId: z66.string().min(1) })
 ]);
-var appointmentSetupVenueChoiceSchema = z68.discriminatedUnion("kind", [
-  z68.object({ kind: z68.literal("none") }),
-  z68.object({ kind: z68.literal("existing"), venueId: z68.string().min(1) }),
-  z68.object({
-    kind: z68.literal("create"),
-    draftId: z68.string().min(1),
-    title: z68.string().trim().min(1),
-    description: z68.string().nullable(),
-    timezone: z68.string().trim().min(1).nullable(),
-    addressJson: z68.record(z68.string(), z68.unknown()),
-    locationJson: z68.object({ lat: z68.number(), lng: z68.number() }).nullable()
+var appointmentSetupVenueChoiceSchema = z66.discriminatedUnion("kind", [
+  z66.object({ kind: z66.literal("none") }),
+  z66.object({ kind: z66.literal("existing"), venueId: z66.string().min(1) }),
+  z66.object({
+    kind: z66.literal("create"),
+    draftId: z66.string().min(1),
+    title: z66.string().trim().min(1),
+    description: z66.string().nullable(),
+    timezone: z66.string().trim().min(1).nullable(),
+    addressJson: z66.record(z66.string(), z66.unknown()),
+    locationJson: z66.object({ lat: z66.number(), lng: z66.number() }).nullable()
   })
 ]);
-var appointmentSetupPaymentDraftSchema = z68.object({
-  priceType: z68.union([z68.literal("free"), z68.literal("paid")])
-});
-var appointmentSetupServiceAssignmentDraftSchema = z68.discriminatedUnion("kind", [
-  z68.object({ kind: z68.literal("all_practitioners") }),
-  z68.object({
-    kind: z68.literal("selected_practitioners"),
-    resourceRefs: z68.array(appointmentSetupRefSchema)
+var appointmentSetupPaymentDraftSchema = z66.object({
+  priceType: z66.union([z66.literal("free"), z66.literal("paid")])
+});
+var appointmentSetupServiceAssignmentDraftSchema = z66.discriminatedUnion("kind", [
+  z66.object({ kind: z66.literal("all_practitioners") }),
+  z66.object({
+    kind: z66.literal("selected_practitioners"),
+    resourceRefs: z66.array(appointmentSetupRefSchema)
   })
 ]);
-var appointmentSetupServiceDraftSchema = z68.object({
+var appointmentSetupServiceDraftSchema = z66.object({
   ref: appointmentSetupRefSchema,
-  title: z68.string().trim().min(1),
-  description: z68.string().nullable(),
-  durationMinutes: z68.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
-  prepMinutes: z68.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-  cleanupMinutes: z68.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
-  priceAmount: z68.number().int().nonnegative().nullable(),
-  isActive: z68.boolean(),
-  locationType: z68.union([
-    z68.literal("virtual"),
-    z68.literal("in_person"),
-    z68.literal("hybrid")
+  title: z66.string().trim().min(1),
+  description: z66.string().nullable(),
+  durationMinutes: z66.number().int().positive().max(APPOINTMENT_SETUP_MAX_MINUTES),
+  prepMinutes: z66.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+  cleanupMinutes: z66.number().int().nonnegative().max(APPOINTMENT_SETUP_MAX_MINUTES).default(0),
+  priceAmount: z66.number().int().nonnegative().nullable(),
+  isActive: z66.boolean(),
+  locationType: z66.union([
+    z66.literal("virtual"),
+    z66.literal("in_person"),
+    z66.literal("hybrid")
   ]),
   venue: appointmentSetupVenueChoiceSchema,
-  timezone: z68.string().trim().min(1).nullable(),
+  timezone: z66.string().trim().min(1).nullable(),
   payment: appointmentSetupPaymentDraftSchema,
   assignment: appointmentSetupServiceAssignmentDraftSchema
 }).superRefine((service, ctx) => {
@@ -41197,49 +41930,49 @@ var appointmentSetupServiceDraftSchema = z68.object({
     });
   }
 });
-var appointmentSetupPractitionerDraftSchema = z68.object({
+var appointmentSetupPractitionerDraftSchema = z66.object({
   ref: appointmentSetupRefSchema,
-  displayName: z68.string().trim().min(1),
-  bio: z68.string().nullable(),
-  timezone: z68.string().trim().min(1),
-  colorHex: z68.string().nullable()
-});
-var appointmentSetupWeeklyWindowDraftSchema = z68.object({
-  weekday: z68.number().int().min(0).max(6),
-  startTime: z68.string(),
-  endTime: z68.string()
-});
-var appointmentSetupStartTimePolicyDraftSchema = z68.discriminatedUnion("kind", [
-  z68.object({ kind: z68.literal("automatic_spacing") }),
-  z68.object({
-    kind: z68.literal("regular_interval"),
-    intervalMinutes: z68.union([
-      z68.literal(10),
-      z68.literal(15),
-      z68.literal(20),
-      z68.literal(30),
-      z68.literal(45),
-      z68.literal(60)
+  displayName: z66.string().trim().min(1),
+  bio: z66.string().nullable(),
+  timezone: z66.string().trim().min(1),
+  colorHex: z66.string().nullable()
+});
+var appointmentSetupWeeklyWindowDraftSchema = z66.object({
+  weekday: z66.number().int().min(0).max(6),
+  startTime: z66.string(),
+  endTime: z66.string()
+});
+var appointmentSetupStartTimePolicyDraftSchema = z66.discriminatedUnion("kind", [
+  z66.object({ kind: z66.literal("automatic_spacing") }),
+  z66.object({
+    kind: z66.literal("regular_interval"),
+    intervalMinutes: z66.union([
+      z66.literal(10),
+      z66.literal(15),
+      z66.literal(20),
+      z66.literal(30),
+      z66.literal(45),
+      z66.literal(60)
     ])
   })
 ]);
-var appointmentSetupAvailabilityDraftSchema = z68.object({
-  kind: z68.literal("weekly_windows"),
+var appointmentSetupAvailabilityDraftSchema = z66.object({
+  kind: z66.literal("weekly_windows"),
   resourceRef: appointmentSetupRefSchema,
   serviceRef: appointmentSetupRefSchema.nullable(),
-  windows: z68.array(appointmentSetupWeeklyWindowDraftSchema),
+  windows: z66.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 = z68.object({
-  minLeadMinutes: z68.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
-  maxBookingNoticeMinutes: z68.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
-});
-var applyAppointmentSetupRequestSchema = z68.object({
-  services: z68.array(appointmentSetupServiceDraftSchema),
-  practitioners: z68.array(appointmentSetupPractitionerDraftSchema),
-  availability: z68.array(appointmentSetupAvailabilityDraftSchema),
+var appointmentSetupBookingNoticeSchema = z66.object({
+  minLeadMinutes: z66.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
+  maxBookingNoticeMinutes: z66.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
+});
+var applyAppointmentSetupRequestSchema = z66.object({
+  services: z66.array(appointmentSetupServiceDraftSchema),
+  practitioners: z66.array(appointmentSetupPractitionerDraftSchema),
+  availability: z66.array(appointmentSetupAvailabilityDraftSchema),
   bookingNotice: appointmentSetupBookingNoticeSchema
 });
 
@@ -41272,24 +42005,24 @@ var STAFF_CANCELLATION_CONTEXT_CATEGORIES = [
 ];
 
 // ../api/src/siteBanner.ts
-import { z as z69 } from "zod";
+import { z as z67 } from "zod";
 var SITE_BANNER_SCOPE_VALUES = ["homepage", "all-pages"];
 var SITE_BANNER_TONE_VALUES = ["announcement", "promotion", "notice", "warning"];
 var SITE_BANNER_MAX_TEXT_LENGTH = 320;
 var SITE_BANNER_MAX_PARAGRAPHS = 2;
-var siteBannerScopeSchema = z69.enum(SITE_BANNER_SCOPE_VALUES);
-var siteBannerToneSchema = z69.enum(SITE_BANNER_TONE_VALUES);
-var siteBannerBodySchema = z69.unknown().transform(unwrapRichTextValue);
-var siteBannerCtaSchema = z69.object({
-  label: z69.string().trim().min(1),
+var siteBannerScopeSchema = z67.enum(SITE_BANNER_SCOPE_VALUES);
+var siteBannerToneSchema = z67.enum(SITE_BANNER_TONE_VALUES);
+var siteBannerBodySchema = z67.unknown().transform(unwrapRichTextValue);
+var siteBannerCtaSchema = z67.object({
+  label: z67.string().trim().min(1),
   link: linkPayloadSchema
 });
-var siteBannerSettingsSchema = z69.discriminatedUnion("enabled", [
-  z69.object({
-    enabled: z69.literal(false)
+var siteBannerSettingsSchema = z67.discriminatedUnion("enabled", [
+  z67.object({
+    enabled: z67.literal(false)
   }),
-  z69.object({
-    enabled: z69.literal(true),
+  z67.object({
+    enabled: z67.literal(true),
     scope: siteBannerScopeSchema,
     tone: siteBannerToneSchema,
     body: siteBannerBodySchema,
@@ -41303,7 +42036,7 @@ var siteBannerSettingsInputSchema = siteBannerSettingsSchema.superRefine((value,
   const analysis = analyzeSiteBannerBody(value.body);
   for (const issue of analysis.issues) {
     ctx.addIssue({
-      code: z69.ZodIssueCode.custom,
+      code: z67.ZodIssueCode.custom,
       path: ["body"],
       message: siteBannerBodyIssueMessage(issue)
     });
@@ -41530,71 +42263,71 @@ function unsafeAsNavigationMenuIdentifier(identifier) {
 var MAIN_NAVIGATION_MENU_IDENTIFIER = unsafeAsNavigationMenuIdentifier("main");
 
 // ../api/src/aiPlayground.ts
-import { z as z70 } from "zod";
-var Rfc6902PatchOp = z70.discriminatedUnion("op", [
+import { z as z68 } from "zod";
+var Rfc6902PatchOp = z68.discriminatedUnion("op", [
   // Standard RFC-6902 operations
-  z70.object({
-    op: z70.literal("add"),
-    path: z70.string(),
-    value: z70.unknown()
+  z68.object({
+    op: z68.literal("add"),
+    path: z68.string(),
+    value: z68.unknown()
   }),
-  z70.object({
-    op: z70.literal("remove"),
-    path: z70.string()
+  z68.object({
+    op: z68.literal("remove"),
+    path: z68.string()
   }),
-  z70.object({
-    op: z70.literal("replace"),
-    path: z70.string(),
-    value: z70.unknown()
+  z68.object({
+    op: z68.literal("replace"),
+    path: z68.string(),
+    value: z68.unknown()
   }),
-  z70.object({
-    op: z70.literal("move"),
-    from: z70.string(),
-    path: z70.string()
+  z68.object({
+    op: z68.literal("move"),
+    from: z68.string(),
+    path: z68.string()
   }),
-  z70.object({
-    op: z70.literal("copy"),
-    from: z70.string(),
-    path: z70.string()
+  z68.object({
+    op: z68.literal("copy"),
+    from: z68.string(),
+    path: z68.string()
   }),
   // Block-level operations (Phase 2)
-  z70.object({
-    op: z70.literal("add_block"),
-    blockKind: z70.string(),
-    afterBlockId: z70.string().nullable(),
-    content: z70.record(z70.string(), z70.unknown()),
-    rationale: z70.string()
+  z68.object({
+    op: z68.literal("add_block"),
+    blockKind: z68.string(),
+    afterBlockId: z68.string().nullable(),
+    content: z68.record(z68.string(), z68.unknown()),
+    rationale: z68.string()
   }),
-  z70.object({
-    op: z70.literal("delete_block"),
-    blockId: z70.string(),
-    rationale: z70.string()
+  z68.object({
+    op: z68.literal("delete_block"),
+    blockId: z68.string(),
+    rationale: z68.string()
   }),
-  z70.object({
-    op: z70.literal("reorder_block"),
-    blockId: z70.string(),
-    afterBlockId: z70.string().nullable(),
-    rationale: z70.string()
+  z68.object({
+    op: z68.literal("reorder_block"),
+    blockId: z68.string(),
+    afterBlockId: z68.string().nullable(),
+    rationale: z68.string()
   })
 ]);
-var PlaygroundProposeRequest = z70.object({
-  request: z70.string().min(1).max(2e3)
+var PlaygroundProposeRequest = z68.object({
+  request: z68.string().min(1).max(2e3)
 });
-var MultiPagePatchEnvelope = z70.object({
-  pageId: z70.string(),
-  blockId: z70.string().optional(),
+var MultiPagePatchEnvelope = z68.object({
+  pageId: z68.string(),
+  blockId: z68.string().optional(),
   // Not present for page-level ops
-  blockKind: z70.string().optional(),
-  blockPurpose: z70.string().optional().nullable(),
-  ops: z70.array(Rfc6902PatchOp),
-  rationale: z70.string(),
-  currentContent: z70.record(z70.string(), z70.unknown()).optional()
-});
-var MultiPageUpdateResponse = z70.object({
-  patches: z70.array(MultiPagePatchEnvelope),
-  assistantMessage: z70.string(),
-  pagesModified: z70.number(),
-  toolCallsUsed: z70.number()
+  blockKind: z68.string().optional(),
+  blockPurpose: z68.string().optional().nullable(),
+  ops: z68.array(Rfc6902PatchOp),
+  rationale: z68.string(),
+  currentContent: z68.record(z68.string(), z68.unknown()).optional()
+});
+var MultiPageUpdateResponse = z68.object({
+  patches: z68.array(MultiPagePatchEnvelope),
+  assistantMessage: z68.string(),
+  pagesModified: z68.number(),
+  toolCallsUsed: z68.number()
 });
 
 // src/data/prefetchBlockData.ts