@riverbankcms/sdk 0.62.2 → 0.64.0

package/dist/server/index.mjs

@@ -436,6 +436,46 @@ var ENDPOINT_DEFINITIONS = {
       "server:internal_error"
     ]
   },
+  listBookingClosures: {
+    path: "/sites/{siteId}/bookings/closures",
+    method: "GET",
+    auth: "user",
+    tags: ["site-{siteId}", "bookings", "closures-{siteId}"],
+    responseKind: "json",
+    errors: ["auth:forbidden", "server:internal_error"]
+  },
+  previewBookingClosure: {
+    path: "/sites/{siteId}/bookings/closures/preview",
+    method: "POST",
+    auth: "user",
+    tags: ["site-{siteId}", "bookings", "closures-{siteId}"],
+    responseKind: "json",
+    errors: ["validation:invalid_input", "auth:forbidden", "server:internal_error"]
+  },
+  createBookingClosure: {
+    path: "/sites/{siteId}/bookings/closures",
+    method: "POST",
+    auth: "user",
+    tags: ["site-{siteId}", "bookings", "closures-{siteId}"],
+    responseKind: "json",
+    errors: ["validation:invalid_input", "resource:conflict", "auth:forbidden", "server:internal_error"]
+  },
+  getBookingClosure: {
+    path: "/sites/{siteId}/bookings/closures/{closureId}",
+    method: "GET",
+    auth: "user",
+    tags: ["site-{siteId}", "bookings", "closures-{siteId}"],
+    responseKind: "json",
+    errors: ["resource:not_found", "server:internal_error"]
+  },
+  deleteBookingClosure: {
+    path: "/sites/{siteId}/bookings/closures/{closureId}",
+    method: "DELETE",
+    auth: "user",
+    tags: ["site-{siteId}", "bookings", "closures-{siteId}"],
+    responseKind: "json",
+    errors: ["resource:not_found", "server:internal_error"]
+  },
   // Ops (event hosts/admins)
   opsListUpcomingEventOccurrences: {
     path: "/ops/sites/{siteId}/events",
@@ -853,7 +893,7 @@ var ENDPOINT_DEFINITIONS = {
     method: "POST",
     auth: "user",
     responseKind: "json",
-    errors: ["validation:invalid_input", "server:internal_error"]
+    errors: ["validation:invalid_input", "billing:plan_limit_exceeded", "server:internal_error"]
   },
   getAppointmentResource: {
     path: "/sites/{siteId}/bookings/resources/{resourceId}",
@@ -1518,6 +1558,31 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  linkCurrentUserPractitioner: {
+    path: "/sites/{siteId}/members/practitioner-link",
+    method: "POST",
+    tags: ["site-{siteId}", "site-members-{siteId}"],
+    auth: "user",
+    responseKind: "json",
+    errors: [
+      "validation:invalid_input",
+      "auth:forbidden",
+      "resource:not_found",
+      "resource:already_exists",
+      "server:internal_error"
+    ]
+  },
+  unlinkCurrentUserPractitioner: {
+    path: "/sites/{siteId}/members/practitioner-link",
+    method: "DELETE",
+    tags: ["site-{siteId}", "site-members-{siteId}"],
+    auth: "user",
+    responseKind: "json",
+    errors: [
+      "auth:forbidden",
+      "server:internal_error"
+    ]
+  },
   authLogin: {
     path: "/auth/login/submit",
     method: "POST",
@@ -1713,6 +1778,42 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  listContentEntryVersions: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/versions",
+    method: "GET",
+    errors: ["validation:invalid_input", "resource:not_found"],
+    tags: [
+      "site-{siteId}",
+      "content-{siteId}-{type}",
+      "content-entry-{entryId}"
+    ],
+    auth: "user",
+    responseKind: "json"
+  },
+  getContentEntryVersion: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/versions/{versionId}",
+    method: "GET",
+    errors: ["validation:invalid_input", "resource:not_found"],
+    tags: [
+      "site-{siteId}",
+      "content-{siteId}-{type}",
+      "content-entry-{entryId}"
+    ],
+    auth: "user",
+    responseKind: "json"
+  },
+  restoreContentEntryVersion: {
+    path: "/sites/{siteId}/content/{type}/{entryId}/versions/{versionId}/restore",
+    method: "POST",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"],
+    tags: [
+      "site-{siteId}",
+      "content-{siteId}-{type}",
+      "content-entry-{entryId}"
+    ],
+    auth: "user",
+    responseKind: "json"
+  },
   updateContentEntryContent: {
     path: "/sites/{siteId}/content/{type}/{entryId}/content",
     method: "PUT",
@@ -2698,6 +2799,14 @@ var ENDPOINT_DEFINITIONS = {
     auth: "user",
     responseKind: "json"
   },
+  saveSiteChromeLookSelection: {
+    path: "/sites/{siteId}/theme/site-chrome-look",
+    method: "POST",
+    tags: [TAG_TEMPLATES.siteCollection, TAG_TEMPLATES.siteTheme],
+    auth: "user",
+    errors: [],
+    responseKind: "json"
+  },
   uploadSiteLogo: {
     path: "/storage/upload-site-logo",
     method: "POST",
@@ -3083,6 +3192,30 @@ var ENDPOINT_DEFINITIONS = {
       "server:internal_error"
     ]
   },
+  listPageVersions: {
+    path: "/sites/{siteId}/pages/{pageId}/versions",
+    method: "GET",
+    errors: ["validation:invalid_input", "resource:not_found"],
+    tags: [TAG_TEMPLATES.siteRoutableContent, TAG_TEMPLATES.pageById],
+    auth: "user",
+    responseKind: "json"
+  },
+  getPageVersion: {
+    path: "/sites/{siteId}/pages/{pageId}/versions/{versionId}",
+    method: "GET",
+    errors: ["validation:invalid_input", "resource:not_found"],
+    tags: [TAG_TEMPLATES.siteRoutableContent, TAG_TEMPLATES.pageById],
+    auth: "user",
+    responseKind: "json"
+  },
+  restorePageVersion: {
+    path: "/sites/{siteId}/pages/{pageId}/versions/{versionId}/restore",
+    method: "POST",
+    errors: ["validation:invalid_input", "resource:not_found", "resource:conflict", "server:internal_error"],
+    tags: [TAG_TEMPLATES.siteRoutableContent, TAG_TEMPLATES.pageById],
+    auth: "user",
+    responseKind: "json"
+  },
   applyPageDesignEditorAction: {
     path: "/sites/{siteId}/pages/{pageId}/design/actions",
     method: "POST",
@@ -3133,21 +3266,21 @@ var ENDPOINT_DEFINITIONS = {
     responseKind: "json"
   },
   updateForm: {
-    path: "/sites/{siteId}/forms/{slug}",
+    path: "/sites/{siteId}/forms/{formId}",
     method: "PATCH",
     tags: [TAG_TEMPLATES.siteForms],
     auth: "user",
     responseKind: "json"
   },
   deleteForm: {
-    path: "/sites/{siteId}/forms/{slug}",
+    path: "/sites/{siteId}/forms/{formId}",
     method: "DELETE",
     tags: [TAG_TEMPLATES.siteForms],
     auth: "user",
     responseKind: "json"
   },
   listFormSubmissions: {
-    path: "/sites/{siteId}/forms/{slug}/submissions",
+    path: "/sites/{siteId}/forms/{formId}/submissions",
     method: "GET",
     revalidate: 30,
     tags: [TAG_TEMPLATES.siteForms, TAG_TEMPLATES.formSubmissionsBySlug],
@@ -3155,7 +3288,7 @@ var ENDPOINT_DEFINITIONS = {
     responseKind: "json"
   },
   createFormSubmissionRectificationAnnotation: {
-    path: "/sites/{siteId}/forms/{slug}/submissions/{submissionId}/annotations",
+    path: "/sites/{siteId}/forms/{formId}/submissions/{submissionId}/annotations",
     method: "POST",
     tags: [TAG_TEMPLATES.siteForms, TAG_TEMPLATES.formSubmissionsBySlug],
     auth: "user",
@@ -3168,7 +3301,7 @@ var ENDPOINT_DEFINITIONS = {
     ]
   },
   exportFormSubmissionsCsv: {
-    path: "/sites/{siteId}/forms/{slug}/submissions/export.csv",
+    path: "/sites/{siteId}/forms/{formId}/submissions/export.csv",
     method: "GET",
     tags: [TAG_TEMPLATES.siteForms, TAG_TEMPLATES.formSubmissionsBySlug],
     auth: "user",
@@ -5118,6 +5251,14 @@ var ENDPOINT_DEFINITIONS = {
     auth: "admin",
     responseKind: "json"
   },
+  adminScheduleBillingComponentEnd: {
+    path: "/admin/sites/{siteId}/billing/components/{componentId}/end",
+    method: "POST",
+    tags: ["admin", "site-{siteId}", "billing"],
+    auth: "admin",
+    responseKind: "json",
+    errors: []
+  },
   // Admin GSC/SEO endpoints
   adminGscVerifyStart: {
     path: "/admin/seo/gsc/properties/verify/start",
@@ -5842,6 +5983,13 @@ var ENDPOINT_DEFINITIONS = {
     auth: "public",
     responseKind: "json"
   },
+  demoClaimMagicLink: {
+    path: "/demo/auth/send-magic-link",
+    method: "POST",
+    auth: "public",
+    responseKind: "json",
+    errors: []
+  },
   previewExchangeCode: {
     path: "/preview/auth/exchange",
     method: "POST",
@@ -6548,7 +6696,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.62.2";
+var SDK_VERSION = "0.64.0";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -8325,61 +8473,74 @@ function createPrebuildLoader(config) {
   return new PrebuildLoader(config);
 }
 
-// ../api/src/navigation/contracts.ts
+// ../api/src/accessAdmin.ts
 import { z } from "zod";
-var portalLinkPayloadSchema = z.object({
-  kind: z.literal("portal"),
-  path: z.string().trim().startsWith("/").optional(),
-  labels: z.object({
-    loggedOut: z.string().trim().min(1).optional(),
-    loggedIn: z.string().trim().min(1).optional()
+var managedDomainAddOnPricingSnapshotSchema = z.object({
+  formulaVersion: z.literal("managed-domain-overage-v1"),
+  conversionRule: z.literal("usd-to-gbp-1-to-1-v1"),
+  registrarAnnualCost: z.number().nonnegative(),
+  registrarCurrency: z.literal("USD"),
+  includedAnnualAllowance: z.number().nonnegative(),
+  includedAnnualAllowanceCurrency: z.literal("USD"),
+  monthlyAmountCents: z.number().int().nonnegative(),
+  monthlyCurrency: z.literal("gbp")
+});
+
+// ../api/src/navigation/contracts.ts
+import { z as z2 } from "zod";
+var portalLinkPayloadSchema = z2.object({
+  kind: z2.literal("portal"),
+  path: z2.string().trim().startsWith("/").optional(),
+  labels: z2.object({
+    loggedOut: z2.string().trim().min(1).optional(),
+    loggedIn: z2.string().trim().min(1).optional()
   }).optional()
 });
-var cartLinkLabelConfigSchema = z.discriminatedUnion("kind", [
-  z.object({
-    kind: z.literal("icon-only")
+var cartLinkLabelConfigSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("icon-only")
   }),
-  z.object({
-    kind: z.literal("icon-with-label"),
-    label: z.string().trim().min(1)
+  z2.object({
+    kind: z2.literal("icon-with-label"),
+    label: z2.string().trim().min(1)
   })
 ]);
-var cartLinkPayloadSchema = z.object({
-  kind: z.literal("cart"),
-  badge: z.enum(["show-count", "hidden"]),
+var cartLinkPayloadSchema = z2.object({
+  kind: z2.literal("cart"),
+  badge: z2.enum(["show-count", "hidden"]),
   label: cartLinkLabelConfigSchema
 });
-var internalLinkPayloadSchema = z.object({
-  kind: z.literal("internal"),
-  routeId: z.string().uuid(),
-  entityId: z.string().uuid(),
-  entityType: z.enum(["page", "content"]),
-  href: z.string().min(1),
-  title: z.string().min(1),
-  typeLabel: z.string().min(1),
-  contentTypeKey: z.string().nullable().optional(),
-  contentTypeName: z.string().nullable().optional(),
-  updatedAt: z.string().nullable().optional()
+var internalLinkPayloadSchema = z2.object({
+  kind: z2.literal("internal"),
+  routeId: z2.string().uuid(),
+  entityId: z2.string().uuid(),
+  entityType: z2.enum(["page", "content"]),
+  href: z2.string().min(1),
+  title: z2.string().min(1),
+  typeLabel: z2.string().min(1),
+  contentTypeKey: z2.string().nullable().optional(),
+  contentTypeName: z2.string().nullable().optional(),
+  updatedAt: z2.string().nullable().optional()
 }).passthrough();
-var externalLinkSchema = z.object({
-  kind: z.literal("external"),
+var externalLinkSchema = z2.object({
+  kind: z2.literal("external"),
   // Navigation external links are expected to be absolute URLs.
-  href: z.string().url()
+  href: z2.string().url()
 });
-var customLinkSchema = z.object({
-  kind: z.literal("url"),
-  href: z.string().min(1)
+var customLinkSchema = z2.object({
+  kind: z2.literal("url"),
+  href: z2.string().min(1)
 });
-var pageLinkSchema = z.object({
-  kind: z.literal("page"),
-  identifier: z.string().min(1)
+var pageLinkSchema = z2.object({
+  kind: z2.literal("page"),
+  identifier: z2.string().min(1)
 });
-var entryLinkSchema = z.object({
-  kind: z.literal("entry"),
-  contentType: z.string().min(1),
-  identifier: z.string().min(1)
+var entryLinkSchema = z2.object({
+  kind: z2.literal("entry"),
+  contentType: z2.string().min(1),
+  identifier: z2.string().min(1)
 });
-var linkPayloadSchema = z.discriminatedUnion("kind", [
+var linkPayloadSchema = z2.discriminatedUnion("kind", [
   internalLinkPayloadSchema,
   pageLinkSchema,
   entryLinkSchema,
@@ -8396,16 +8557,16 @@ var navigationLinkInputSchemaOptions = [
   portalLinkPayloadSchema,
   cartLinkPayloadSchema
 ];
-var navigationLinkInputSchema = z.discriminatedUnion(
+var navigationLinkInputSchema = z2.discriminatedUnion(
   "kind",
   navigationLinkInputSchemaOptions
 );
 
 // ../api/src/sdkConfig/contracts.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // ../blocks/src/system/manifest/schema.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../media-core/src/aspectTransforms.ts
 function parseAspectRatioValue(value) {
@@ -8432,44 +8593,44 @@ function parseAspectRatioValue(value) {
 }
 
 // ../blocks/src/system/node/schema.ts
-import { z as z2 } from "zod";
-var transformStepSchema = z2.object({
-  id: z2.string().min(1, "Transform requires an identifier"),
-  options: z2.record(z2.string(), z2.unknown()).optional()
+import { z as z3 } from "zod";
+var transformStepSchema = z3.object({
+  id: z3.string().min(1, "Transform requires an identifier"),
+  options: z3.record(z3.string(), z3.unknown()).optional()
 });
-var bindingPathSchema = z2.string().min(1, "Binding path is required").regex(/[A-Za-z0-9_\.$\[\]/-]+/, "Binding path contains invalid characters");
-var bindingSchema = z2.object({
+var bindingPathSchema = z3.string().min(1, "Binding path is required").regex(/[A-Za-z0-9_\.$\[\]/-]+/, "Binding path contains invalid characters");
+var bindingSchema = z3.object({
   from: bindingPathSchema,
-  fallback: z2.unknown().optional(),
+  fallback: z3.unknown().optional(),
   transforms: transformStepSchema.array().default([]),
-  pick: z2.enum(["value", "collection", "context"]).default("value"),
-  coerce: z2.enum(["number", "boolean", "string"]).optional()
+  pick: z3.enum(["value", "collection", "context"]).default("value"),
+  coerce: z3.enum(["number", "boolean", "string"]).optional()
 });
-var repeatSchema = z2.object({
+var repeatSchema = z3.object({
   collection: bindingSchema,
-  itemName: z2.string().min(1).default("item"),
-  indexName: z2.string().min(1).default("index"),
-  limit: z2.number().int().positive().optional(),
-  sortBy: z2.object({
+  itemName: z3.string().min(1).default("item"),
+  indexName: z3.string().min(1).default("index"),
+  limit: z3.number().int().positive().optional(),
+  sortBy: z3.object({
     path: bindingPathSchema,
-    direction: z2.enum(["asc", "desc"]).default("asc")
+    direction: z3.enum(["asc", "desc"]).default("asc")
   }).optional()
 });
-var conditionSchema = z2.object({
+var conditionSchema = z3.object({
   when: bindingSchema,
-  equals: z2.unknown().optional(),
-  not: z2.boolean().default(false)
+  equals: z3.unknown().optional(),
+  not: z3.boolean().default(false)
 });
-var dataScopeSchema = z2.object({
-  name: z2.string().min(1),
+var dataScopeSchema = z3.object({
+  name: z3.string().min(1),
   from: bindingSchema
 });
-var nodePropsSchema = z2.record(z2.string(), z2.unknown()).default({});
-var nodeSchema = z2.object({
-  type: z2.string().min(1, "Node type is required"),
-  key: z2.string().optional(),
+var nodePropsSchema = z3.record(z3.string(), z3.unknown()).default({});
+var nodeSchema = z3.object({
+  type: z3.string().min(1, "Node type is required"),
+  key: z3.string().optional(),
   props: nodePropsSchema.optional(),
-  children: z2.lazy(() => nodeSchema.array().default([])).optional(),
+  children: z3.lazy(() => nodeSchema.array().default([])).optional(),
   $bind: bindingSchema.optional(),
   $repeat: repeatSchema.optional(),
   $when: conditionSchema.optional(),
@@ -8533,93 +8694,93 @@ var siteOptionSources = [
   "venues",
   "staffMembers"
 ];
-var mediaDeliverySchema = z3.object({
-  sizes: z3.string().optional(),
-  widthCandidates: z3.array(z3.number().int().positive()).optional(),
-  maxCssWidth: z3.number().positive().optional(),
-  maxCssHeight: z3.number().positive().optional(),
-  strategy: z3.enum(["default", "columnsAuto", "imageGalleryVariant"]).optional(),
-  strategyOptions: z3.record(z3.string(), z3.unknown()).optional()
+var mediaDeliverySchema = z4.object({
+  sizes: z4.string().optional(),
+  widthCandidates: z4.array(z4.number().int().positive()).optional(),
+  maxCssWidth: z4.number().positive().optional(),
+  maxCssHeight: z4.number().positive().optional(),
+  strategy: z4.enum(["default", "columnsAuto", "imageGalleryVariant"]).optional(),
+  strategyOptions: z4.record(z4.string(), z4.unknown()).optional()
 });
-var selectOptionSchema = z3.object({
-  value: z3.string(),
-  label: z3.string(),
-  description: z3.string().optional(),
-  icon: z3.string().optional()
+var selectOptionSchema = z4.object({
+  value: z4.string(),
+  label: z4.string(),
+  description: z4.string().optional(),
+  icon: z4.string().optional()
 });
-var selectSourceSchema = z3.discriminatedUnion("kind", [
-  z3.object({
-    kind: z3.literal("static")
+var selectSourceSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("static")
   }),
-  z3.object({
-    kind: z3.literal("site"),
-    optionSource: z3.enum(siteOptionSources)
+  z4.object({
+    kind: z4.literal("site"),
+    optionSource: z4.enum(siteOptionSources)
   }),
-  z3.object({
-    kind: z3.literal("sdk")
+  z4.object({
+    kind: z4.literal("sdk")
   })
 ]);
 function assertNeverSelectSource(value) {
   throw new Error(`Unhandled select source: ${JSON.stringify(value)}`);
 }
-var uiSchema = z3.object({
-  widget: z3.string().optional(),
+var uiSchema = z4.object({
+  widget: z4.string().optional(),
   // Container/widget presets (used by Group/Repeater widgets themselves, not for widget selection)
-  preset: z3.enum(["disclosure"]).optional(),
-  flattenInRepeater: z3.boolean().optional(),
-  hidden: z3.boolean().optional(),
-  hideLabel: z3.boolean().optional(),
-  hideDescription: z3.boolean().optional(),
-  showCharCount: z3.union([
-    z3.number().int().positive(),
-    z3.object({ max: z3.number().int().positive() })
+  preset: z4.enum(["disclosure"]).optional(),
+  flattenInRepeater: z4.boolean().optional(),
+  hidden: z4.boolean().optional(),
+  hideLabel: z4.boolean().optional(),
+  hideDescription: z4.boolean().optional(),
+  showCharCount: z4.union([
+    z4.number().int().positive(),
+    z4.object({ max: z4.number().int().positive() })
   ]).optional(),
-  showSlugPreview: z3.boolean().optional(),
-  variant: z3.enum(["full", "inline", "limited", "media", "notes"]).optional(),
-  richTextVariant: z3.enum(["full", "inline", "limited", "media", "notes"]).optional(),
-  cropEditorMode: z3.enum(["dialog", "inline"]).optional(),
-  cropEditorAutoOpen: z3.boolean().optional(),
-  mediaPickerAutoOpen: z3.boolean().optional(),
-  showMediaPreview: z3.boolean().optional(),
-  showMediaOverlayActions: z3.boolean().optional(),
+  showSlugPreview: z4.boolean().optional(),
+  variant: z4.enum(["full", "inline", "limited", "media", "notes"]).optional(),
+  richTextVariant: z4.enum(["full", "inline", "limited", "media", "notes"]).optional(),
+  cropEditorMode: z4.enum(["dialog", "inline"]).optional(),
+  cropEditorAutoOpen: z4.boolean().optional(),
+  mediaPickerAutoOpen: z4.boolean().optional(),
+  showMediaPreview: z4.boolean().optional(),
+  showMediaOverlayActions: z4.boolean().optional(),
   mediaDelivery: mediaDeliverySchema.optional(),
-  mediaDeliveryByVariant: z3.record(z3.string(), mediaDeliverySchema).optional(),
+  mediaDeliveryByVariant: z4.record(z4.string(), mediaDeliverySchema).optional(),
   // Optional input hints for validators/widgets
-  inputType: z3.enum(["text", "email", "tel", "number"]).optional(),
-  min: z3.number().optional(),
-  max: z3.number().optional(),
-  step: z3.number().optional(),
-  showValue: z3.boolean().optional(),
-  pattern: z3.string().optional(),
-  placeholder: z3.string().optional(),
-  visibleWhen: z3.object({
-    field: z3.string().min(1),
-    equals: z3.any().optional(),
-    notEquals: z3.any().optional(),
-    oneOf: z3.array(z3.any()).optional(),
-    notIn: z3.array(z3.any()).optional()
+  inputType: z4.enum(["text", "email", "tel", "number"]).optional(),
+  min: z4.number().optional(),
+  max: z4.number().optional(),
+  step: z4.number().optional(),
+  showValue: z4.boolean().optional(),
+  pattern: z4.string().optional(),
+  placeholder: z4.string().optional(),
+  visibleWhen: z4.object({
+    field: z4.string().min(1),
+    equals: z4.any().optional(),
+    notEquals: z4.any().optional(),
+    oneOf: z4.array(z4.any()).optional(),
+    notIn: z4.array(z4.any()).optional()
   }).optional(),
   // Modal configuration for modal and group fields
-  modalConfig: z3.object({
-    buttonLabel: z3.string().optional(),
-    description: z3.string().optional(),
-    buttonVariant: z3.enum(["default", "outline"]).optional(),
-    showCustomizedIndicator: z3.boolean().optional(),
-    maxWidth: z3.string().optional()
+  modalConfig: z4.object({
+    buttonLabel: z4.string().optional(),
+    description: z4.string().optional(),
+    buttonVariant: z4.enum(["default", "outline"]).optional(),
+    showCustomizedIndicator: z4.boolean().optional(),
+    maxWidth: z4.string().optional()
   }).optional(),
   // Background field configuration
-  allowedTypes: z3.array(z3.enum(["color", "gradient", "image"])).optional(),
+  allowedTypes: z4.array(z4.enum(["color", "gradient", "image"])).optional(),
   // Tab group configuration
-  fullWidth: z3.boolean().optional(),
+  fullWidth: z4.boolean().optional(),
   // Field layout configuration
-  row: z3.string().optional(),
-  colSpan: z3.number().int().min(1).max(4).optional(),
+  row: z4.string().optional(),
+  colSpan: z4.number().int().min(1).max(4).optional(),
   // Group layout configuration
-  layout: z3.enum(["stack", "grid"]).optional(),
-  columns: z3.number().int().min(2).max(4).optional(),
+  layout: z4.enum(["stack", "grid"]).optional(),
+  columns: z4.number().int().min(2).max(4).optional(),
   // Named grid presets for GroupField grid layout.
   // Use these for common responsive patterns to avoid embedding Tailwind strings in manifests.
-  gridColsPreset: z3.enum([
+  gridColsPreset: z4.enum([
     "simple2",
     // base 1 col -> sm 2 cols
     "simple3",
@@ -8632,99 +8793,99 @@ var uiSchema = z3.object({
   // Responsive grid columns for GroupField grid layout (mobile-first).
   // Uses Tailwind breakpoints; when provided, GroupField will build the appropriate
   // `grid-cols-*` classes from this config.
-  gridColumns: z3.object({
-    base: z3.number().int().min(1).max(4).optional(),
-    sm: z3.number().int().min(1).max(4).optional(),
-    md: z3.number().int().min(1).max(4).optional(),
-    lg: z3.number().int().min(1).max(4).optional(),
-    xl: z3.number().int().min(1).max(4).optional()
+  gridColumns: z4.object({
+    base: z4.number().int().min(1).max(4).optional(),
+    sm: z4.number().int().min(1).max(4).optional(),
+    md: z4.number().int().min(1).max(4).optional(),
+    lg: z4.number().int().min(1).max(4).optional(),
+    xl: z4.number().int().min(1).max(4).optional()
   }).optional(),
   // Group grid override: allows custom responsive grid column classes (e.g. unequal column widths)
-  gridColsClassName: z3.string().optional(),
+  gridColsClassName: z4.string().optional(),
   // Repeater presentation presets
-  repeaterPreset: z3.enum(["thumbnailGrid", "layoutGrid"]).optional(),
-  thumbnailField: z3.string().optional(),
-  thumbnailAltField: z3.string().optional(),
-  thumbnailLabelField: z3.string().optional(),
-  thumbnailAspectRatio: z3.string().optional(),
-  thumbnailCardDensity: z3.enum(["compact", "comfortable"]).optional(),
-  layoutGridColumnsFields: z3.object({
-    base: z3.string().optional(),
-    sm: z3.string().optional(),
-    md: z3.string().optional(),
-    lg: z3.string().min(1),
-    xl: z3.string().optional()
+  repeaterPreset: z4.enum(["thumbnailGrid", "layoutGrid"]).optional(),
+  thumbnailField: z4.string().optional(),
+  thumbnailAltField: z4.string().optional(),
+  thumbnailLabelField: z4.string().optional(),
+  thumbnailAspectRatio: z4.string().optional(),
+  thumbnailCardDensity: z4.enum(["compact", "comfortable"]).optional(),
+  layoutGridColumnsFields: z4.object({
+    base: z4.string().optional(),
+    sm: z4.string().optional(),
+    md: z4.string().optional(),
+    lg: z4.string().min(1),
+    xl: z4.string().optional()
   }).optional(),
-  layoutGridSpanField: z3.string().optional(),
-  layoutGridRowField: z3.string().optional(),
-  layoutGridColumnField: z3.string().optional(),
-  layoutGridMaxRows: z3.number().int().positive().optional(),
+  layoutGridSpanField: z4.string().optional(),
+  layoutGridRowField: z4.string().optional(),
+  layoutGridColumnField: z4.string().optional(),
+  layoutGridMaxRows: z4.number().int().positive().optional(),
   // Icon picker configuration (used when ui.widget === 'iconPicker')
-  iconPickerPreset: z3.enum(["cta"]).optional(),
+  iconPickerPreset: z4.enum(["cta"]).optional(),
   // Entry picker configuration
-  contentTypeField: z3.string().optional(),
-  fixedContentType: z3.string().optional(),
-  valueFrom: z3.enum(["id", "identifier", "slug"]).optional(),
-  siteOptionSource: z3.enum(siteOptionSources).optional(),
-  searchThreshold: z3.number().int().positive().optional(),
+  contentTypeField: z4.string().optional(),
+  fixedContentType: z4.string().optional(),
+  valueFrom: z4.enum(["id", "identifier", "slug"]).optional(),
+  siteOptionSource: z4.enum(siteOptionSources).optional(),
+  searchThreshold: z4.number().int().positive().optional(),
   // Render in block header instead of form body (used for section styles)
-  renderInHeader: z3.boolean().optional(),
+  renderInHeader: z4.boolean().optional(),
   // Semantic field intent for content-first form routing and settings tab grouping
-  intent: z3.enum(["content", "display", "behavior", "style"]).optional()
+  intent: z4.enum(["content", "display", "behavior", "style"]).optional()
 }).partial();
-var baseFieldSchema = z3.object({
-  id: z3.string().min(1, "Field id is required"),
-  label: z3.string().min(1, "Field label is required"),
-  description: z3.string().optional(),
-  visibleRoles: z3.array(z3.enum(visibilityLevels)).optional(),
-  defaultValue: z3.any().optional(),
-  required: z3.boolean().default(false),
+var baseFieldSchema = z4.object({
+  id: z4.string().min(1, "Field id is required"),
+  label: z4.string().min(1, "Field label is required"),
+  description: z4.string().optional(),
+  visibleRoles: z4.array(z4.enum(visibilityLevels)).optional(),
+  defaultValue: z4.any().optional(),
+  required: z4.boolean().default(false),
   ui: uiSchema.optional()
 });
 var textFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("text"),
-  multiline: z3.boolean().default(false),
-  maxLength: z3.number().int().positive().optional()
+  type: z4.literal("text"),
+  multiline: z4.boolean().default(false),
+  maxLength: z4.number().int().positive().optional()
 });
 var richTextFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("richText")
+  type: z4.literal("richText")
 });
 var mediaFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("media"),
-  mediaKinds: z3.array(
-    z3.enum(["image", "video", "audio", "document", "spreadsheet", "archive"])
+  type: z4.literal("media"),
+  mediaKinds: z4.array(
+    z4.enum(["image", "video", "audio", "document", "spreadsheet", "archive"])
   ).default(["image"]),
-  aspectRatio: z3.string().optional()
+  aspectRatio: z4.string().optional()
 });
 var booleanFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("boolean")
+  type: z4.literal("boolean")
 });
 var dateFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("date")
+  type: z4.literal("date")
 });
 var timeFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("time")
+  type: z4.literal("time")
 });
 var dateTimeFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("datetime")
+  type: z4.literal("datetime")
 });
 var slugFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("slug"),
-  sourceFieldId: z3.string().min(1).optional(),
-  statusFieldId: z3.string().min(1).optional(),
-  maxLength: z3.number().int().positive().optional()
+  type: z4.literal("slug"),
+  sourceFieldId: z4.string().min(1).optional(),
+  statusFieldId: z4.string().min(1).optional(),
+  maxLength: z4.number().int().positive().optional()
 });
 var urlFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("url"),
-  allowRelative: z3.boolean().default(false)
+  type: z4.literal("url"),
+  allowRelative: z4.boolean().default(false)
 });
 var linkFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("link")
+  type: z4.literal("link")
 });
 var selectFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("select"),
-  options: z3.array(selectOptionSchema),
-  multiple: z3.boolean().default(false),
+  type: z4.literal("select"),
+  options: z4.array(selectOptionSchema),
+  multiple: z4.boolean().default(false),
   source: selectSourceSchema.optional()
 }).superRefine((field, ctx) => {
   const widget = field.ui?.widget;
@@ -8732,7 +8893,7 @@ var selectFieldSchema = baseFieldSchema.extend({
   if (!field.source) {
     if (siteOptionSource || widget === "sdkSelect") {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         message: "Runtime-backed select fields must declare source.kind explicitly",
         path: ["source"]
       });
@@ -8740,7 +8901,7 @@ var selectFieldSchema = baseFieldSchema.extend({
     }
     if (field.options.length === 0) {
       ctx.addIssue({
-        code: z3.ZodIssueCode.custom,
+        code: z4.ZodIssueCode.custom,
         message: "Select fields require at least one option unless a runtime source is configured",
         path: ["options"]
       });
@@ -8751,14 +8912,14 @@ var selectFieldSchema = baseFieldSchema.extend({
     case "static":
       if (siteOptionSource || widget === "sdkSelect") {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "Static select fields cannot declare runtime-backed UI metadata",
           path: ["ui"]
         });
       }
       if (field.options.length === 0) {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "Static select fields require at least one option",
           path: ["options"]
         });
@@ -8767,21 +8928,21 @@ var selectFieldSchema = baseFieldSchema.extend({
     case "site":
       if (field.options.length > 0) {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "Site-backed select fields must not define static options",
           path: ["options"]
         });
       }
       if (widget !== "siteOptionPicker") {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "Site-backed select fields must use the siteOptionPicker widget",
           path: ["ui", "widget"]
         });
       }
       if (siteOptionSource !== field.source.optionSource) {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "Site-backed select fields must keep ui.siteOptionSource in sync with source.optionSource",
           path: ["ui", "siteOptionSource"]
         });
@@ -8790,14 +8951,14 @@ var selectFieldSchema = baseFieldSchema.extend({
     case "sdk":
       if (widget !== "sdkSelect") {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "SDK-backed select fields must use the sdkSelect widget",
           path: ["ui", "widget"]
         });
       }
       if (siteOptionSource) {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "SDK-backed select fields cannot declare ui.siteOptionSource",
           path: ["ui", "siteOptionSource"]
         });
@@ -8808,33 +8969,33 @@ var selectFieldSchema = baseFieldSchema.extend({
   }
 });
 var referenceFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("reference"),
-  referenceKind: z3.string().min(1),
-  allowManualEntry: z3.boolean().default(false)
+  type: z4.literal("reference"),
+  referenceKind: z4.string().min(1),
+  allowManualEntry: z4.boolean().default(false)
 });
-var itemTypeSchema = z3.object({
-  label: z3.string().min(1),
-  icon: z3.string().optional(),
-  fields: z3.lazy(
+var itemTypeSchema = z4.object({
+  label: z4.string().min(1),
+  icon: z4.string().optional(),
+  fields: z4.lazy(
     () => getFieldSchemaInternal().array().min(1, "Item type requires at least one field")
   )
 });
 var repeaterFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("repeater"),
-  itemLabel: z3.string().default("Item"),
-  itemLabelSource: z3.string().optional(),
-  minItems: z3.number().int().min(0).default(0),
-  maxItems: z3.number().int().positive().optional(),
+  type: z4.literal("repeater"),
+  itemLabel: z4.string().default("Item"),
+  itemLabelSource: z4.string().optional(),
+  minItems: z4.number().int().min(0).default(0),
+  maxItems: z4.number().int().positive().optional(),
   // Monomorphic mode
-  schema: z3.object({
-    fields: z3.lazy(
+  schema: z4.object({
+    fields: z4.lazy(
       () => getFieldSchemaInternal().array().min(1, "Repeater requires at least one field")
     )
   }).optional(),
   // Polymorphic mode
-  polymorphic: z3.boolean().optional(),
-  itemTypes: z3.record(z3.string(), itemTypeSchema).optional(),
-  allowConversion: z3.boolean().default(true)
+  polymorphic: z4.boolean().optional(),
+  itemTypes: z4.record(z4.string(), itemTypeSchema).optional(),
+  allowConversion: z4.boolean().default(true)
 }).refine(
   (data) => {
     const hasSchema = data.schema !== void 0;
@@ -8926,78 +9087,78 @@ var repeaterFieldSchema = baseFieldSchema.extend({
   }
 );
 var groupFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("group"),
-  schema: z3.object({
-    fields: z3.lazy(
+  type: z4.literal("group"),
+  schema: z4.object({
+    fields: z4.lazy(
       () => getFieldSchemaInternal().array().min(1, "Group requires at least one field")
     )
   })
 });
 var modalFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("modal"),
-  schema: z3.object({
-    fields: z3.lazy(
+  type: z4.literal("modal"),
+  schema: z4.object({
+    fields: z4.lazy(
       () => getFieldSchemaInternal().array().min(1, "Modal requires at least one field")
     )
   })
 });
 var numberFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("number"),
-  min: z3.number().optional(),
-  max: z3.number().optional(),
-  step: z3.number().optional()
+  type: z4.literal("number"),
+  min: z4.number().optional(),
+  max: z4.number().optional(),
+  step: z4.number().optional()
 });
-var tabDefinitionSchema = z3.object({
-  id: z3.string().min(1),
-  label: z3.string().min(1),
-  icon: z3.string().optional(),
-  description: z3.string().optional(),
-  fields: z3.lazy(() => getFieldSchemaInternal().array()),
+var tabDefinitionSchema = z4.object({
+  id: z4.string().min(1),
+  label: z4.string().min(1),
+  icon: z4.string().optional(),
+  description: z4.string().optional(),
+  fields: z4.lazy(() => getFieldSchemaInternal().array()),
   /** SDK section option that controls tab visibility based on site config */
-  sdkSectionOption: z3.enum(["backgroundColor", "backgroundGradient", "backgroundImage"]).optional()
+  sdkSectionOption: z4.enum(["backgroundColor", "backgroundGradient", "backgroundImage"]).optional()
 });
 var tabGroupFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("tabGroup"),
-  tabs: z3.array(tabDefinitionSchema).min(1, "TabGroup requires at least one tab"),
-  activeTabField: z3.string().optional()
+  type: z4.literal("tabGroup"),
+  tabs: z4.array(tabDefinitionSchema).min(1, "TabGroup requires at least one tab"),
+  activeTabField: z4.string().optional()
 });
-var presetOptionSchema = z3.object({
-  value: z3.string(),
-  label: z3.string()
+var presetOptionSchema = z4.object({
+  value: z4.string(),
+  label: z4.string()
 });
 var presetOrCustomFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("presetOrCustom"),
-  presets: z3.array(presetOptionSchema).min(1, "PresetOrCustom requires at least one preset"),
-  customInput: z3.object({
-    placeholder: z3.string().optional(),
-    pattern: z3.string().optional(),
-    helpText: z3.string().optional()
+  type: z4.literal("presetOrCustom"),
+  presets: z4.array(presetOptionSchema).min(1, "PresetOrCustom requires at least one preset"),
+  customInput: z4.object({
+    placeholder: z4.string().optional(),
+    pattern: z4.string().optional(),
+    helpText: z4.string().optional()
   }).optional()
 });
 var contentTypeSelectFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("contentTypeSelect"),
+  type: z4.literal("contentTypeSelect"),
   /** Filter: all, routable (hasPages=true), nonRoutable (hasPages=false) */
-  filter: z3.enum(["all", "routable", "nonRoutable"]).default("all")
+  filter: z4.enum(["all", "routable", "nonRoutable"]).default("all")
 });
 var entryPickerFieldSchema = baseFieldSchema.extend({
-  type: z3.literal("entryPicker"),
+  type: z4.literal("entryPicker"),
   // Note: these options also exist under `ui.*` (see uiSchema) because older manifests
   // and some authoring surfaces store widget-specific configuration there. We support
   // both locations so SDK/custom manifests can use the more ergonomic top-level fields
   // without breaking existing `ui.*` configs.
   /** Fixed content type to filter entries by (no sibling contentType field required) */
-  fixedContentType: z3.string().optional(),
+  fixedContentType: z4.string().optional(),
   /** Field ID that contains the content type to filter entries by */
-  contentTypeField: z3.string().optional(),
+  contentTypeField: z4.string().optional(),
   /** What value should be stored when an entry is selected */
-  valueFrom: z3.enum(["id", "identifier", "slug"]).optional()
+  valueFrom: z4.enum(["id", "identifier", "slug"]).optional()
 });
 var _fieldSchemaInternal = null;
 function getFieldSchemaInternal() {
   if (_fieldSchemaInternal) {
     return _fieldSchemaInternal;
   }
-  _fieldSchemaInternal = z3.discriminatedUnion("type", [
+  _fieldSchemaInternal = z4.discriminatedUnion("type", [
     textFieldSchema,
     richTextFieldSchema,
     mediaFieldSchema,
@@ -9032,14 +9193,14 @@ var fieldSchema = new Proxy({}, {
     return prop in getFieldSchemaInternal();
   }
 });
-var slotSchema = z3.object({
-  id: z3.string().min(1),
-  label: z3.string().min(1),
-  allowedKinds: z3.array(z3.string()).default([]),
-  min: z3.number().int().min(0).default(0),
-  max: z3.number().int().positive().optional(),
-  help: z3.string().optional(),
-  visibleRoles: z3.array(z3.enum(visibilityLevels)).optional()
+var slotSchema = z4.object({
+  id: z4.string().min(1),
+  label: z4.string().min(1),
+  allowedKinds: z4.array(z4.string()).default([]),
+  min: z4.number().int().min(0).default(0),
+  max: z4.number().int().positive().optional(),
+  help: z4.string().optional(),
+  visibleRoles: z4.array(z4.enum(visibilityLevels)).optional()
 });
 var typographyTokens = [
   "display",
@@ -9057,24 +9218,24 @@ var colorTokens = [
 ];
 var spacingTokens = ["none", "xs", "sm", "md", "lg", "xl"];
 var radiusTokens = ["none", "sm", "md", "lg", "full"];
-var styleTokenSchema = z3.object({
-  background: z3.enum(colorTokens).optional(),
-  foreground: z3.enum(colorTokens).optional(),
-  border: z3.enum(colorTokens).optional(),
-  typography: z3.enum(typographyTokens).optional(),
-  spacing: z3.enum(spacingTokens).optional(),
-  radius: z3.enum(radiusTokens).optional()
+var styleTokenSchema = z4.object({
+  background: z4.enum(colorTokens).optional(),
+  foreground: z4.enum(colorTokens).optional(),
+  border: z4.enum(colorTokens).optional(),
+  typography: z4.enum(typographyTokens).optional(),
+  spacing: z4.enum(spacingTokens).optional(),
+  radius: z4.enum(radiusTokens).optional()
 });
-var behaviourSchema = z3.object({
-  supportsThemeSwitching: z3.boolean().default(true),
-  inlineEditing: z3.boolean().default(false),
-  animation: z3.boolean().default(false),
+var behaviourSchema = z4.object({
+  supportsThemeSwitching: z4.boolean().default(true),
+  inlineEditing: z4.boolean().default(false),
+  animation: z4.boolean().default(false),
   // Hide from block picker palettes (e.g., header/footer system blocks)
-  paletteHidden: z3.boolean().default(false),
+  paletteHidden: z4.boolean().default(false),
   // Block manages its own wrapper (for sticky/fixed positioning)
-  managesOwnWrapper: z3.boolean().optional()
+  managesOwnWrapper: z4.boolean().optional()
 });
-var blockCategoryEnum = z3.enum([
+var blockCategoryEnum = z4.enum([
   "marketing",
   "content",
   "blog",
@@ -9082,13 +9243,13 @@ var blockCategoryEnum = z3.enum([
   "layout",
   "interactive"
 ]);
-var manifestSchema = z3.object({
-  name: z3.string().min(1),
-  version: z3.string().min(1),
-  title: z3.string().min(1),
-  titleSource: z3.union([z3.string().min(1), z3.array(z3.string().min(1)).min(1)]).optional(),
-  description: z3.string().optional(),
-  component: z3.string().min(1),
+var manifestSchema = z4.object({
+  name: z4.string().min(1),
+  version: z4.string().min(1),
+  title: z4.string().min(1),
+  titleSource: z4.union([z4.string().min(1), z4.array(z4.string().min(1)).min(1)]).optional(),
+  description: z4.string().optional(),
+  component: z4.string().min(1),
   fields: fieldSchema.array().default([]),
   slots: slotSchema.array().default([]),
   styleTokens: styleTokenSchema.optional(),
@@ -9101,23 +9262,23 @@ var manifestSchema = z3.object({
    *
    * The original fields remain available in settings for power users.
    */
-  promotedFields: z3.array(z3.string().min(1)).optional(),
+  promotedFields: z4.array(z4.string().min(1)).optional(),
   // Block variants system
-  variants: z3.record(z3.string(), NodeTreeSchema).optional(),
-  defaultVariant: z3.string().optional(),
-  variantOptions: z3.record(
-    z3.string(),
-    z3.object({
-      label: z3.string().optional(),
-      description: z3.string().optional(),
-      icon: z3.string().optional()
+  variants: z4.record(z4.string(), NodeTreeSchema).optional(),
+  defaultVariant: z4.string().optional(),
+  variantOptions: z4.record(
+    z4.string(),
+    z4.object({
+      label: z4.string().optional(),
+      description: z4.string().optional(),
+      icon: z4.string().optional()
     }).optional()
   ).optional(),
   // Discovery metadata
   category: blockCategoryEnum.optional(),
-  contentTypes: z3.array(z3.string()).optional(),
-  tags: z3.array(z3.string()).optional(),
-  icon: z3.string().optional()
+  contentTypes: z4.array(z4.string()).optional(),
+  tags: z4.array(z4.string()).optional(),
+  icon: z4.string().optional()
 });
 
 // ../blocks/src/system/data/loaderEndpoints.ts
@@ -9139,17 +9300,17 @@ var SUPPORTED_LOADER_ENDPOINTS = [
 function unsafeRetypeZodSchema(schema) {
   return schema;
 }
-var navIdListSchema = z4.preprocess((value) => {
+var navIdListSchema = z5.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;
-}, z4.array(z4.string()).max(200).optional());
-var dashboardNavVisibilityBaseSchema = z4.object({
-  mode: z4.enum(["augment", "restrict"]).optional(),
+}, z5.array(z5.string()).max(200).optional());
+var dashboardNavVisibilityBaseSchema = z5.object({
+  mode: z5.enum(["augment", "restrict"]).optional(),
   allowIds: navIdListSchema,
   denyIds: navIdListSchema
 }).strip();
-var dashboardNavVisibilityRolesSchema = z4.object({
+var dashboardNavVisibilityRolesSchema = z5.object({
   administrator: dashboardNavVisibilityBaseSchema.optional(),
   editor: dashboardNavVisibilityBaseSchema.optional(),
   team_member: dashboardNavVisibilityBaseSchema.optional(),
@@ -9158,57 +9319,57 @@ var dashboardNavVisibilityRolesSchema = z4.object({
 var dashboardNavVisibilitySchema = dashboardNavVisibilityBaseSchema.extend({
   roles: dashboardNavVisibilityRolesSchema
 }).strip();
-var dashboardNavigationConfigSchema = z4.object({
+var dashboardNavigationConfigSchema = z5.object({
   siteNav: dashboardNavVisibilitySchema.optional(),
   settingsNav: dashboardNavVisibilitySchema.optional()
 }).strip();
-var dashboardConfigSchema = z4.object({
-  previewEditingEnabled: z4.boolean().optional(),
+var dashboardConfigSchema = z5.object({
+  previewEditingEnabled: z5.boolean().optional(),
   navigation: dashboardNavigationConfigSchema.optional()
 }).strip();
 var fieldDefinitionInputSchema = unsafeRetypeZodSchema(fieldSchema);
 var nodeDefinitionSchema = unsafeRetypeZodSchema(NodeSchema);
-var sdkLoaderEndpointSchema = z4.enum(SUPPORTED_LOADER_ENDPOINTS);
-var loaderParamBindingSchema = z4.object({
-  $bind: z4.object({
-    from: z4.string().min(1, "Binding path is required"),
-    fallback: z4.string().optional()
+var sdkLoaderEndpointSchema = z5.enum(SUPPORTED_LOADER_ENDPOINTS);
+var loaderParamBindingSchema = z5.object({
+  $bind: z5.object({
+    from: z5.string().min(1, "Binding path is required"),
+    fallback: z5.string().optional()
   })
 });
-var loaderParamValueSchema = z4.union([
-  z4.string(),
-  z4.number(),
-  z4.boolean(),
+var loaderParamValueSchema = z5.union([
+  z5.string(),
+  z5.number(),
+  z5.boolean(),
   loaderParamBindingSchema
 ]);
-var sdkConfigLoaderSchema = z4.object({
+var sdkConfigLoaderSchema = z5.object({
   endpoint: sdkLoaderEndpointSchema,
-  params: z4.record(z4.string(), loaderParamValueSchema),
-  mode: z4.enum(["server", "client"]).default("server")
+  params: z5.record(z5.string(), loaderParamValueSchema),
+  mode: z5.enum(["server", "client"]).default("server")
 });
-var sdkDataLoadersSchema = z4.record(z4.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
-var sdkCustomBlockIdSchema = z4.string().min(8).regex(/^custom\.[a-z][a-z0-9-]*$/, {
+var sdkDataLoadersSchema = z5.record(z5.string(), sdkConfigLoaderSchema).refine((loaders) => Object.keys(loaders).length <= 5, { message: "Maximum 5 data loaders per block" }).optional();
+var sdkCustomBlockIdSchema = z5.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 = z4.object({
+var sdkCustomBlockInputSchema = z5.object({
   id: sdkCustomBlockIdSchema,
-  title: z4.string().min(1),
-  titleSource: z4.union([z4.string().min(1), z4.array(z4.string().min(1)).min(1)]).optional(),
-  description: z4.string().optional(),
+  title: z5.string().min(1),
+  titleSource: z5.union([z5.string().min(1), z5.array(z5.string().min(1)).min(1)]).optional(),
+  description: z5.string().optional(),
   category: blockCategoryEnum,
-  icon: z4.string().optional(),
-  tags: z4.array(z4.string()).optional(),
+  icon: z5.string().optional(),
+  tags: z5.array(z5.string()).optional(),
   fields: fieldDefinitionInputSchema.array().min(1),
   dataLoaders: sdkDataLoadersSchema,
   layout: NodeSchema.optional(),
-  variants: z4.record(z4.string().min(1), NodeSchema).optional(),
-  defaultVariant: z4.string().min(1).optional(),
-  variantOptions: z4.record(
-    z4.string().min(1),
-    z4.object({
-      label: z4.string().min(1).optional(),
-      description: z4.string().min(1).optional(),
-      icon: z4.string().min(1).optional()
+  variants: z5.record(z5.string().min(1), NodeSchema).optional(),
+  defaultVariant: z5.string().min(1).optional(),
+  variantOptions: z5.record(
+    z5.string().min(1),
+    z5.object({
+      label: z5.string().min(1).optional(),
+      description: z5.string().min(1).optional(),
+      icon: z5.string().min(1).optional()
     })
   ).optional()
 }).superRefine((data, ctx) => {
@@ -9218,7 +9379,7 @@ var sdkCustomBlockInputSchema = z4.object({
       const exists = data.fields.some((field) => field.id === source);
       if (!exists) {
         ctx.addIssue({
-          code: z4.ZodIssueCode.custom,
+          code: z5.ZodIssueCode.custom,
           message: `titleSource must reference a valid field ID (got "${source}")`,
           path: Array.isArray(data.titleSource) ? ["titleSource", index] : ["titleSource"]
         });
@@ -9227,7 +9388,7 @@ var sdkCustomBlockInputSchema = z4.object({
   }
   if (data.layout && data.variants) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       message: "Custom block must define either `layout` or `variants`, not both",
       path: ["variants"]
     });
@@ -9236,14 +9397,14 @@ var sdkCustomBlockInputSchema = z4.object({
     const keys = Object.keys(data.variants);
     if (keys.length === 0) {
       ctx.addIssue({
-        code: z4.ZodIssueCode.custom,
+        code: z5.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: z4.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         message: "`defaultVariant` must be a key present in `variants`",
         path: ["defaultVariant"]
       });
@@ -9252,7 +9413,7 @@ var sdkCustomBlockInputSchema = z4.object({
       for (const key of Object.keys(data.variantOptions)) {
         if (!Object.prototype.hasOwnProperty.call(data.variants, key)) {
           ctx.addIssue({
-            code: z4.ZodIssueCode.custom,
+            code: z5.ZodIssueCode.custom,
             message: "`variantOptions` key must exist in `variants`",
             path: ["variantOptions", key]
           });
@@ -9261,74 +9422,74 @@ var sdkCustomBlockInputSchema = z4.object({
     }
   }
 });
-var sdkBlockFieldExtensionInputSchema = z4.object({
+var sdkBlockFieldExtensionInputSchema = z5.object({
   fields: fieldDefinitionInputSchema.array().min(1)
 });
-var sdkBlockFieldExtensionsInputSchema = z4.record(
-  z4.string().min(1),
+var sdkBlockFieldExtensionsInputSchema = z5.record(
+  z5.string().min(1),
   sdkBlockFieldExtensionInputSchema
 );
-var sdkThemePaletteSchema = z4.record(z4.string(), z4.string());
-var sdkThemeConfigSchema = z4.object({
+var sdkThemePaletteSchema = z5.record(z5.string(), z5.string());
+var sdkThemeConfigSchema = z5.object({
   palette: sdkThemePaletteSchema
 });
-var sdkSectionBackgroundSchema = z4.object({
-  id: z4.string().min(1),
-  label: z4.string().min(1),
-  token: z4.string().min(1)
+var sdkSectionBackgroundSchema = z5.object({
+  id: z5.string().min(1),
+  label: z5.string().min(1),
+  token: z5.string().min(1)
 });
-var sdkSectionOptionsConfigSchema = z4.object({
-  backgroundColor: z4.boolean().optional(),
-  backgroundImage: z4.boolean().optional(),
-  backgroundGradient: z4.boolean().optional(),
-  spacing: z4.union([z4.array(z4.enum(["compact", "default", "spacious"])), z4.boolean()]).optional(),
-  textColor: z4.boolean().optional()
+var sdkSectionOptionsConfigSchema = z5.object({
+  backgroundColor: z5.boolean().optional(),
+  backgroundImage: z5.boolean().optional(),
+  backgroundGradient: z5.boolean().optional(),
+  spacing: z5.union([z5.array(z5.enum(["compact", "default", "spacious"])), z5.boolean()]).optional(),
+  textColor: z5.boolean().optional()
 });
-var sdkContainerOptionsConfigSchema = z4.object({
-  maxWidth: z4.union([z4.array(z4.enum(["narrow", "default", "wide", "full"])), z4.boolean()]).optional(),
-  alignment: z4.union([z4.array(z4.enum(["left", "center", "right"])), z4.boolean()]).optional()
+var sdkContainerOptionsConfigSchema = z5.object({
+  maxWidth: z5.union([z5.array(z5.enum(["narrow", "default", "wide", "full"])), z5.boolean()]).optional(),
+  alignment: z5.union([z5.array(z5.enum(["left", "center", "right"])), z5.boolean()]).optional()
 });
-var sdkSiteStyleConfigSchema = z4.object({
-  sectionBackgrounds: z4.array(sdkSectionBackgroundSchema).optional(),
+var sdkSiteStyleConfigSchema = z5.object({
+  sectionBackgrounds: z5.array(sdkSectionBackgroundSchema).optional(),
   sectionOptions: sdkSectionOptionsConfigSchema.optional(),
   containerOptions: sdkContainerOptionsConfigSchema.optional()
 });
-var sdkSiteLayoutConfigSchema = z4.object({
-  footerBlocks: z4.array(
-    z4.object({
-      id: z4.string().min(1).optional(),
-      kind: z4.string().min(1),
-      content: z4.record(z4.string(), z4.unknown()).optional()
+var sdkSiteLayoutConfigSchema = z5.object({
+  footerBlocks: z5.array(
+    z5.object({
+      id: z5.string().min(1).optional(),
+      kind: z5.string().min(1),
+      content: z5.record(z5.string(), z5.unknown()).optional()
     })
   ).optional()
 });
-var sdkFieldSelectOptionSchema = z4.object({
-  value: z4.string(),
-  label: z4.string()
+var sdkFieldSelectOptionSchema = z5.object({
+  value: z5.string(),
+  label: z5.string()
 });
-var sdkBlockFieldConfigSchema = z4.object({
-  options: z4.array(sdkFieldSelectOptionSchema).optional()
+var sdkBlockFieldConfigSchema = z5.object({
+  options: z5.array(sdkFieldSelectOptionSchema).optional()
 });
-var sdkBlockFieldOptionsMapSchema = z4.record(
-  z4.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
+var sdkBlockFieldOptionsMapSchema = z5.record(
+  z5.string().regex(/^(block\.|custom\.)[a-z][a-z0-9-]*$/, {
     message: "Block ID must be 'block.*' or 'custom.*' format"
   }),
-  z4.record(z4.string().min(1), sdkBlockFieldConfigSchema)
+  z5.record(z5.string().min(1), sdkBlockFieldConfigSchema)
 ).optional();
-var sdkContentTypeTemplateConfigSchema = z4.object({
-  blocks: z4.array(z4.unknown())
+var sdkContentTypeTemplateConfigSchema = z5.object({
+  blocks: z5.array(z5.unknown())
 }).passthrough();
-var sdkContentTypeConfigSchema = z4.object({
-  key: z4.string().min(1),
-  fields: z4.array(z4.unknown()),
+var sdkContentTypeConfigSchema = z5.object({
+  key: z5.string().min(1),
+  fields: z5.array(z5.unknown()),
   template: sdkContentTypeTemplateConfigSchema.nullable().optional()
 }).passthrough();
-var sdkContentConfigSchema = z4.object({
-  contentTypes: z4.array(sdkContentTypeConfigSchema).optional(),
-  pages: z4.array(z4.unknown()).optional(),
-  entries: z4.array(z4.unknown()).optional(),
-  navigationMenus: z4.array(z4.unknown()).optional(),
-  settings: z4.unknown().optional()
+var sdkContentConfigSchema = z5.object({
+  contentTypes: z5.array(sdkContentTypeConfigSchema).optional(),
+  pages: z5.array(z5.unknown()).optional(),
+  entries: z5.array(z5.unknown()).optional(),
+  navigationMenus: z5.array(z5.unknown()).optional(),
+  settings: z5.unknown().optional()
 }).passthrough();
 var SDK_WORKFLOW_ID_MAX_LENGTH = 120;
 var SDK_WORKFLOW_TITLE_MAX_LENGTH = 120;
@@ -9336,46 +9497,69 @@ var SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH = 500;
 var SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH = 120;
 var SDK_WORKFLOW_ENDPOINT_MAX_LENGTH = 500;
 var SDK_WORKFLOW_TRIGGER_MAX_COUNT = 5;
+var SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH = 120;
+var SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT = 10;
 var SDK_WORKFLOW_MAX_COUNT = 50;
 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 = z4.string().min(1).max(SDK_WORKFLOW_ID_MAX_LENGTH).regex(SDK_WORKFLOW_ID_PATTERN, {
+var sdkWorkflowIdSchema = z5.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 = z4.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 = z4.object({
-  type: z4.literal("manual")
+var sdkWorkflowEndpointSchema = z5.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 = z5.object({
+  type: z5.literal("manual")
+}).strict();
+var sdkWorkflowTriggerFieldSchema = z5.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 = z5.object({
+  field: sdkWorkflowTriggerFieldSchema,
+  changed: z5.literal(true)
+}).strict();
+var sdkWorkflowFieldEmptyConditionSchema = z5.object({
+  field: sdkWorkflowTriggerFieldSchema,
+  isEmpty: z5.boolean()
+}).strict();
+var sdkWorkflowEntryDraftUpdatedTriggerSchema = z5.object({
+  type: z5.literal("entry.draft.updated"),
+  when: z5.array(
+    z5.union([
+      sdkWorkflowFieldChangedConditionSchema,
+      sdkWorkflowFieldEmptyConditionSchema
+    ])
+  ).min(1).max(SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT)
 }).strict();
-var sdkWorkflowTriggerSchema = z4.discriminatedUnion("type", [
-  sdkWorkflowManualTriggerSchema
+var sdkWorkflowTriggerSchema = z5.discriminatedUnion("type", [
+  sdkWorkflowManualTriggerSchema,
+  sdkWorkflowEntryDraftUpdatedTriggerSchema
 ]);
-var sdkWorkflowConfirmationSchema = z4.object({
-  title: z4.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
-  body: z4.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
+var sdkWorkflowConfirmationSchema = z5.object({
+  title: z5.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH),
+  body: z5.string().trim().min(1).max(SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH).optional()
 }).strict();
-var sdkWorkflowConfigSchema = z4.object({
+var sdkWorkflowConfigSchema = z5.object({
   id: sdkWorkflowIdSchema,
-  title: z4.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
-  description: z4.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
-  contentType: z4.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
+  title: z5.string().trim().min(1).max(SDK_WORKFLOW_TITLE_MAX_LENGTH),
+  description: z5.string().trim().min(1).max(SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH).optional(),
+  contentType: z5.string().trim().min(1).max(SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH),
   endpoint: sdkWorkflowEndpointSchema,
-  triggers: z4.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
+  triggers: z5.array(sdkWorkflowTriggerSchema).min(1).max(SDK_WORKFLOW_TRIGGER_MAX_COUNT),
   confirmation: sdkWorkflowConfirmationSchema.optional()
 }).strict();
-var sdkWorkflowsSchema = z4.array(sdkWorkflowConfigSchema).max(SDK_WORKFLOW_MAX_COUNT, "Maximum 50 workflows per site").refine((workflows) => {
+var sdkWorkflowsSchema = z5.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 = z4.object({
-  siteId: z4.string().uuid(),
-  previewUrl: z4.string().url().optional(),
-  liveUrl: z4.string().url().optional(),
+var riverbankSiteConfigInputSchema = z5.object({
+  siteId: z5.string().uuid(),
+  previewUrl: z5.string().url().optional(),
+  liveUrl: z5.string().url().optional(),
   theme: sdkThemeConfigSchema.optional(),
   styles: sdkSiteStyleConfigSchema.optional(),
   layout: sdkSiteLayoutConfigSchema.optional(),
-  customBlocks: z4.array(sdkCustomBlockInputSchema).max(100, "Maximum 100 custom blocks per site").refine((blocks) => {
+  customBlocks: z5.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(),
@@ -9383,48 +9567,51 @@ var riverbankSiteConfigInputSchema = z4.object({
   blockFieldExtensions: sdkBlockFieldExtensionsInputSchema.optional(),
   workflows: sdkWorkflowsSchema,
   content: sdkContentConfigSchema.optional(),
-  contentDir: z4.string().optional(),
-  sync: z4.object({
-    existingEntries: z4.enum(["skip", "update"]).optional()
+  contentDir: z5.string().optional(),
+  sync: z5.object({
+    existingEntries: z5.enum(["skip", "update"]).optional()
   }).optional(),
-  deploy: z4.object({
-    verifyCommand: z4.string().optional(),
-    prebuildOutput: z4.string().optional()
+  deploy: z5.object({
+    verifyCommand: z5.string().optional(),
+    prebuildOutput: z5.string().optional()
   }).optional(),
-  themeSource: z4.enum(["local", "cms"]).optional(),
-  activeTheme: z4.string().optional(),
-  enablePortal: z4.boolean().optional(),
+  themeSource: z5.enum(["local", "cms"]).optional(),
+  activeTheme: z5.string().optional(),
+  enablePortal: z5.boolean().optional(),
   dashboard: dashboardConfigSchema.optional()
 }).strict();
-var pushSdkConfigBodySchema = z4.object({
+var pushSdkConfigBodySchema = z5.object({
   config: riverbankSiteConfigInputSchema,
-  forceContentTypes: z4.boolean().optional()
+  forceContentTypes: z5.boolean().optional()
 }).strict();
 
 // ../api/src/siteOnboarding.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS = {
   configure_appointments: {
     requirementId: "configure_appointments",
     reason: "launch_anyway"
   }
 };
-var acknowledgeLaunchRequirementRequestSchema = z5.discriminatedUnion(
+var acknowledgeLaunchRequirementRequestSchema = z6.discriminatedUnion(
   "requirementId",
   [
-    z5.object({
-      requirementId: z5.literal("review_generated_site")
+    z6.object({
+      requirementId: z6.literal("review_generated_site")
     }),
-    z5.object({
-      requirementId: z5.literal(
+    z6.object({
+      requirementId: z6.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.requirementId
       ),
-      overrideReason: z5.literal(
+      overrideReason: z6.literal(
         LAUNCH_REQUIREMENT_OVERRIDE_DEFINITIONS.configure_appointments.reason
       )
     })
   ]
 );
+var goLiveSiteRequestSchema = z6.object({
+  acceptExtraSiteCharge: z6.boolean().optional()
+});
 
 // ../api/src/customerMembershipOutcomes.ts
 var CANONICAL_REFUND_CONFLICT_CODES = [
@@ -9597,79 +9784,79 @@ function isRecord2(value) {
 }
 
 // ../api/src/appointmentSetup.ts
-import { z as z6 } from "zod";
-var appointmentSetupRefSchema = z6.discriminatedUnion("kind", [
-  z6.object({ kind: z6.literal("existing"), id: z6.string().min(1) }),
-  z6.object({ kind: z6.literal("new"), draftId: z6.string().min(1) })
+import { z as z7 } from "zod";
+var appointmentSetupRefSchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("existing"), id: z7.string().min(1) }),
+  z7.object({ kind: z7.literal("new"), draftId: z7.string().min(1) })
 ]);
-var appointmentSetupVenueChoiceSchema = z6.discriminatedUnion("kind", [
-  z6.object({ kind: z6.literal("none") }),
-  z6.object({ kind: z6.literal("existing"), venueId: z6.string().min(1) }),
-  z6.object({
-    kind: z6.literal("create"),
-    draftId: z6.string().min(1),
-    title: z6.string().trim().min(1),
-    description: z6.string().nullable(),
-    timezone: z6.string().trim().min(1).nullable(),
-    addressJson: z6.record(z6.string(), z6.unknown()),
-    locationJson: z6.object({ lat: z6.number(), lng: z6.number() }).nullable()
+var appointmentSetupVenueChoiceSchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("none") }),
+  z7.object({ kind: z7.literal("existing"), venueId: z7.string().min(1) }),
+  z7.object({
+    kind: z7.literal("create"),
+    draftId: z7.string().min(1),
+    title: z7.string().trim().min(1),
+    description: z7.string().nullable(),
+    timezone: z7.string().trim().min(1).nullable(),
+    addressJson: z7.record(z7.string(), z7.unknown()),
+    locationJson: z7.object({ lat: z7.number(), lng: z7.number() }).nullable()
   })
 ]);
-var appointmentSetupPaymentDraftSchema = z6.object({
-  priceType: z6.union([z6.literal("free"), z6.literal("paid")])
+var appointmentSetupPaymentDraftSchema = z7.object({
+  priceType: z7.union([z7.literal("free"), z7.literal("paid")])
 });
-var appointmentSetupServiceAssignmentDraftSchema = z6.discriminatedUnion("kind", [
-  z6.object({ kind: z6.literal("all_practitioners") }),
-  z6.object({
-    kind: z6.literal("selected_practitioners"),
-    resourceRefs: z6.array(appointmentSetupRefSchema)
+var appointmentSetupServiceAssignmentDraftSchema = z7.discriminatedUnion("kind", [
+  z7.object({ kind: z7.literal("all_practitioners") }),
+  z7.object({
+    kind: z7.literal("selected_practitioners"),
+    resourceRefs: z7.array(appointmentSetupRefSchema)
   })
 ]);
-var appointmentSetupServiceDraftSchema = z6.object({
+var appointmentSetupServiceDraftSchema = z7.object({
   ref: appointmentSetupRefSchema,
-  title: z6.string().trim().min(1),
-  description: z6.string().nullable(),
-  durationMinutes: z6.number().int().positive(),
-  priceAmount: z6.number().int().nonnegative().nullable(),
-  isActive: z6.boolean(),
-  locationType: z6.union([
-    z6.literal("virtual"),
-    z6.literal("in_person"),
-    z6.literal("hybrid")
+  title: z7.string().trim().min(1),
+  description: z7.string().nullable(),
+  durationMinutes: z7.number().int().positive(),
+  priceAmount: z7.number().int().nonnegative().nullable(),
+  isActive: z7.boolean(),
+  locationType: z7.union([
+    z7.literal("virtual"),
+    z7.literal("in_person"),
+    z7.literal("hybrid")
   ]),
   venue: appointmentSetupVenueChoiceSchema,
-  timezone: z6.string().trim().min(1).nullable(),
+  timezone: z7.string().trim().min(1).nullable(),
   payment: appointmentSetupPaymentDraftSchema,
   assignment: appointmentSetupServiceAssignmentDraftSchema
 });
-var appointmentSetupPractitionerDraftSchema = z6.object({
+var appointmentSetupPractitionerDraftSchema = z7.object({
   ref: appointmentSetupRefSchema,
-  displayName: z6.string().trim().min(1),
-  bio: z6.string().nullable(),
-  timezone: z6.string().trim().min(1),
-  colorHex: z6.string().nullable()
+  displayName: z7.string().trim().min(1),
+  bio: z7.string().nullable(),
+  timezone: z7.string().trim().min(1),
+  colorHex: z7.string().nullable()
 });
-var appointmentSetupWeeklyWindowDraftSchema = z6.object({
-  weekday: z6.number().int().min(0).max(6),
-  startTime: z6.string(),
-  endTime: z6.string()
+var appointmentSetupWeeklyWindowDraftSchema = z7.object({
+  weekday: z7.number().int().min(0).max(6),
+  startTime: z7.string(),
+  endTime: z7.string()
 });
-var appointmentSetupAvailabilityDraftSchema = z6.object({
-  kind: z6.literal("weekly_windows"),
+var appointmentSetupAvailabilityDraftSchema = z7.object({
+  kind: z7.literal("weekly_windows"),
   resourceRef: appointmentSetupRefSchema,
   serviceRef: appointmentSetupRefSchema.nullable(),
-  windows: z6.array(appointmentSetupWeeklyWindowDraftSchema)
+  windows: z7.array(appointmentSetupWeeklyWindowDraftSchema)
 });
 var APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX = 28 * 24 * 60;
 var APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX = 10 * 365 * 24 * 60;
-var appointmentSetupBookingNoticeSchema = z6.object({
-  minLeadMinutes: z6.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
-  maxBookingNoticeMinutes: z6.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
+var appointmentSetupBookingNoticeSchema = z7.object({
+  minLeadMinutes: z7.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MIN_LEAD_MINUTES_MAX),
+  maxBookingNoticeMinutes: z7.number().int().nonnegative().max(APPOINTMENT_DEFAULT_MAX_BOOKING_NOTICE_MINUTES_MAX)
 });
-var applyAppointmentSetupRequestSchema = z6.object({
-  services: z6.array(appointmentSetupServiceDraftSchema),
-  practitioners: z6.array(appointmentSetupPractitionerDraftSchema),
-  availability: z6.array(appointmentSetupAvailabilityDraftSchema),
+var applyAppointmentSetupRequestSchema = z7.object({
+  services: z7.array(appointmentSetupServiceDraftSchema),
+  practitioners: z7.array(appointmentSetupPractitionerDraftSchema),
+  availability: z7.array(appointmentSetupAvailabilityDraftSchema),
   bookingNotice: appointmentSetupBookingNoticeSchema
 });
 
@@ -9702,24 +9889,24 @@ var STAFF_CANCELLATION_CONTEXT_CATEGORIES = [
 ];
 
 // ../api/src/siteBanner.ts
-import { z as z7 } from "zod";
+import { z as z8 } 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 = z7.enum(SITE_BANNER_SCOPE_VALUES);
-var siteBannerToneSchema = z7.enum(SITE_BANNER_TONE_VALUES);
-var siteBannerBodySchema = z7.unknown().transform(unwrapRichTextValue);
-var siteBannerCtaSchema = z7.object({
-  label: z7.string().trim().min(1),
+var siteBannerScopeSchema = z8.enum(SITE_BANNER_SCOPE_VALUES);
+var siteBannerToneSchema = z8.enum(SITE_BANNER_TONE_VALUES);
+var siteBannerBodySchema = z8.unknown().transform(unwrapRichTextValue);
+var siteBannerCtaSchema = z8.object({
+  label: z8.string().trim().min(1),
   link: linkPayloadSchema
 });
-var siteBannerSettingsSchema = z7.discriminatedUnion("enabled", [
-  z7.object({
-    enabled: z7.literal(false)
+var siteBannerSettingsSchema = z8.discriminatedUnion("enabled", [
+  z8.object({
+    enabled: z8.literal(false)
   }),
-  z7.object({
-    enabled: z7.literal(true),
+  z8.object({
+    enabled: z8.literal(true),
     scope: siteBannerScopeSchema,
     tone: siteBannerToneSchema,
     body: siteBannerBodySchema,
@@ -9733,7 +9920,7 @@ var siteBannerSettingsInputSchema = siteBannerSettingsSchema.superRefine((value,
   const analysis = analyzeSiteBannerBody(value.body);
   for (const issue of analysis.issues) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z8.ZodIssueCode.custom,
       path: ["body"],
       message: siteBannerBodyIssueMessage(issue)
     });
@@ -9922,71 +10109,71 @@ function collectText(node) {
 }
 
 // ../api/src/aiPlayground.ts
-import { z as z8 } from "zod";
-var Rfc6902PatchOp = z8.discriminatedUnion("op", [
+import { z as z9 } from "zod";
+var Rfc6902PatchOp = z9.discriminatedUnion("op", [
   // Standard RFC-6902 operations
-  z8.object({
-    op: z8.literal("add"),
-    path: z8.string(),
-    value: z8.unknown()
+  z9.object({
+    op: z9.literal("add"),
+    path: z9.string(),
+    value: z9.unknown()
   }),
-  z8.object({
-    op: z8.literal("remove"),
-    path: z8.string()
+  z9.object({
+    op: z9.literal("remove"),
+    path: z9.string()
   }),
-  z8.object({
-    op: z8.literal("replace"),
-    path: z8.string(),
-    value: z8.unknown()
+  z9.object({
+    op: z9.literal("replace"),
+    path: z9.string(),
+    value: z9.unknown()
   }),
-  z8.object({
-    op: z8.literal("move"),
-    from: z8.string(),
-    path: z8.string()
+  z9.object({
+    op: z9.literal("move"),
+    from: z9.string(),
+    path: z9.string()
   }),
-  z8.object({
-    op: z8.literal("copy"),
-    from: z8.string(),
-    path: z8.string()
+  z9.object({
+    op: z9.literal("copy"),
+    from: z9.string(),
+    path: z9.string()
   }),
   // Block-level operations (Phase 2)
-  z8.object({
-    op: z8.literal("add_block"),
-    blockKind: z8.string(),
-    afterBlockId: z8.string().nullable(),
-    content: z8.record(z8.string(), z8.unknown()),
-    rationale: z8.string()
+  z9.object({
+    op: z9.literal("add_block"),
+    blockKind: z9.string(),
+    afterBlockId: z9.string().nullable(),
+    content: z9.record(z9.string(), z9.unknown()),
+    rationale: z9.string()
   }),
-  z8.object({
-    op: z8.literal("delete_block"),
-    blockId: z8.string(),
-    rationale: z8.string()
+  z9.object({
+    op: z9.literal("delete_block"),
+    blockId: z9.string(),
+    rationale: z9.string()
   }),
-  z8.object({
-    op: z8.literal("reorder_block"),
-    blockId: z8.string(),
-    afterBlockId: z8.string().nullable(),
-    rationale: z8.string()
+  z9.object({
+    op: z9.literal("reorder_block"),
+    blockId: z9.string(),
+    afterBlockId: z9.string().nullable(),
+    rationale: z9.string()
   })
 ]);
-var PlaygroundProposeRequest = z8.object({
-  request: z8.string().min(1).max(2e3)
+var PlaygroundProposeRequest = z9.object({
+  request: z9.string().min(1).max(2e3)
 });
-var MultiPagePatchEnvelope = z8.object({
-  pageId: z8.string(),
-  blockId: z8.string().optional(),
+var MultiPagePatchEnvelope = z9.object({
+  pageId: z9.string(),
+  blockId: z9.string().optional(),
   // Not present for page-level ops
-  blockKind: z8.string().optional(),
-  blockPurpose: z8.string().optional().nullable(),
-  ops: z8.array(Rfc6902PatchOp),
-  rationale: z8.string(),
-  currentContent: z8.record(z8.string(), z8.unknown()).optional()
+  blockKind: z9.string().optional(),
+  blockPurpose: z9.string().optional().nullable(),
+  ops: z9.array(Rfc6902PatchOp),
+  rationale: z9.string(),
+  currentContent: z9.record(z9.string(), z9.unknown()).optional()
 });
-var MultiPageUpdateResponse = z8.object({
-  patches: z8.array(MultiPagePatchEnvelope),
-  assistantMessage: z8.string(),
-  pagesModified: z8.number(),
-  toolCallsUsed: z8.number()
+var MultiPageUpdateResponse = z9.object({
+  patches: z9.array(MultiPagePatchEnvelope),
+  assistantMessage: z9.string(),
+  pagesModified: z9.number(),
+  toolCallsUsed: z9.number()
 });
 
 // src/public-api/runtime.ts