@riverbankcms/sdk 0.60.6 → 0.60.9

package/dist/preview-next/client/runtime.mjs

@@ -5,7 +5,7 @@ import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 import * as ReactDOM5 from 'react-dom';
 import ReactDOM5__default, { createPortal, unstable_batchedUpdates } from 'react-dom';
 import deepEqual6 from 'fast-deep-equal';
-import z37, { z } from 'zod';
+import z38, { z } from 'zod';
 import { QueryClient, MutationCache, QueryCache, QueryClientProvider, useQueryClient, useMutation, useQuery } from '@tanstack/react-query';
 import { createRoot } from 'react-dom/client';
 import { useRouter } from 'next/navigation';
@@ -1049,13 +1049,150 @@ var init_endpoints = __esm({
           "server:internal_error"
         ]
       },
-      deleteAppointmentResource: {
+      removeAppointmentResource: {
         path: "/sites/{siteId}/bookings/resources/{resourceId}",
         method: "DELETE",
         auth: "user",
         responseKind: "json",
         errors: ["resource:not_found", "server:internal_error"]
       },
+      createTeamMemberProfile: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile",
+        method: "POST",
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      updateTeamMemberProfilePolicy: {
+        path: "/sites/{siteId}/bookings/resources/profile-policy",
+        method: "PUT",
+        auth: "user",
+        responseKind: "json",
+        errors: ["validation:invalid_input", "server:internal_error"]
+      },
+      updateTeamMemberProfileContent: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile/{entryId}/content",
+        method: "PUT",
+        tags: [
+          "site-{siteId}",
+          "content-{siteId}-team-member",
+          "content-entry-{entryId}"
+        ],
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      publishTeamMemberProfile: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile/{entryId}/publish",
+        method: "POST",
+        tags: [
+          "site-{siteId}",
+          "content-{siteId}-team-member",
+          "content-entry-{entryId}"
+        ],
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "server:internal_error"
+        ]
+      },
+      discardTeamMemberProfileDraft: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile/{entryId}/discard",
+        method: "POST",
+        tags: [
+          "site-{siteId}",
+          "content-{siteId}-team-member",
+          "content-entry-{entryId}"
+        ],
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      unpublishTeamMemberProfile: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile/{entryId}/unpublish",
+        method: "POST",
+        tags: [
+          "site-{siteId}",
+          "content-{siteId}-team-member",
+          "content-entry-{entryId}"
+        ],
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      scheduleTeamMemberProfile: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile/{entryId}/schedule",
+        method: "POST",
+        tags: [
+          "site-{siteId}",
+          "content-{siteId}-team-member",
+          "content-entry-{entryId}"
+        ],
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      cancelScheduledTeamMemberProfile: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile/{entryId}/schedule",
+        method: "DELETE",
+        tags: [
+          "site-{siteId}",
+          "content-{siteId}-team-member",
+          "content-entry-{entryId}"
+        ],
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
+      updateTeamMemberProfileRouteMetadata: {
+        path: "/sites/{siteId}/bookings/resources/{resourceId}/profile/routes/{routeId}/metadata",
+        method: "PATCH",
+        tags: [
+          TAG_TEMPLATES.siteCollection,
+          TAG_TEMPLATES.siteRoutableContent,
+          TAG_TEMPLATES.routeById
+        ],
+        auth: "user",
+        responseKind: "json",
+        errors: [
+          "validation:invalid_input",
+          "resource:not_found",
+          "resource:conflict",
+          "server:internal_error"
+        ]
+      },
       listAppointmentServices: {
         path: "/sites/{siteId}/bookings/services",
         method: "GET",
@@ -3429,6 +3566,15 @@ var init_endpoints = __esm({
         auth: "public",
         responseKind: "json"
       },
+      listPublicTeamMembers: {
+        path: "/public/sites/{siteId}/team-members",
+        method: "GET",
+        revalidate: 60,
+        tags: ["public-team-members-{siteId}"],
+        errors: [],
+        auth: "public",
+        responseKind: "json"
+      },
       getPublicCourse: {
         path: "/public/sites/{siteId}/courses/{courseId}",
         method: "GET",
@@ -57636,7 +57782,7 @@ var init_index_esm = __esm({
       const isRadio = isRadioInput(ref);
       const isCheckBox = isCheckBoxInput(ref);
       const isRadioOrCheckbox = isRadio || isCheckBox;
-      const isEmpty2 = (valueAsNumber || isFileInput(ref)) && isUndefined(ref.value) && isUndefined(inputValue) || isHTMLElement2(ref) && ref.value === "" || inputValue === "" || Array.isArray(inputValue) && !inputValue.length;
+      const isEmpty = (valueAsNumber || isFileInput(ref)) && isUndefined(ref.value) && isUndefined(inputValue) || isHTMLElement2(ref) && ref.value === "" || inputValue === "" || Array.isArray(inputValue) && !inputValue.length;
       const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
       const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {
         const message2 = exceedMax ? maxLengthMessage : minLengthMessage;
@@ -57647,7 +57793,7 @@ var init_index_esm = __esm({
           ...appendErrorsCurry(exceedMax ? maxType : minType, message2)
         };
       };
-      if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox && (isEmpty2 || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) {
+      if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox && (isEmpty || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) {
         const { value, message: message2 } = isString(required) ? { value: !!required, message: required } : getValueAndMessage(required);
         if (value) {
           error[name] = {
@@ -57662,7 +57808,7 @@ var init_index_esm = __esm({
           }
         }
       }
-      if (!isEmpty2 && (!isNullOrUndefined(min3) || !isNullOrUndefined(max3))) {
+      if (!isEmpty && (!isNullOrUndefined(min3) || !isNullOrUndefined(max3))) {
         let exceedMax;
         let exceedMin;
         const maxOutput = getValueAndMessage(max3);
@@ -57695,7 +57841,7 @@ var init_index_esm = __esm({
           }
         }
       }
-      if ((maxLength || minLength) && !isEmpty2 && (isString(inputValue) || isFieldArray && Array.isArray(inputValue))) {
+      if ((maxLength || minLength) && !isEmpty && (isString(inputValue) || isFieldArray && Array.isArray(inputValue))) {
         const maxLengthOutput = getValueAndMessage(maxLength);
         const minLengthOutput = getValueAndMessage(minLength);
         const exceedMax = !isNullOrUndefined(maxLengthOutput.value) && inputValue.length > +maxLengthOutput.value;
@@ -57708,7 +57854,7 @@ var init_index_esm = __esm({
           }
         }
       }
-      if (pattern && !isEmpty2 && isString(inputValue)) {
+      if (pattern && !isEmpty && isString(inputValue)) {
         const { value: patternValue, message: message2 } = getValueAndMessage(pattern);
         if (isRegex(patternValue) && !inputValue.match(patternValue)) {
           error[name] = {
@@ -88021,8 +88167,8 @@ var init_dist57 = __esm({
               if (empty2 || !allWasSelected) {
                 return;
               }
-              const isEmpty2 = isNodeEmpty(newState.doc);
-              if (!isEmpty2) {
+              const isEmpty = isNodeEmpty(newState.doc);
+              if (!isEmpty) {
                 return;
               }
               const tr3 = newState.tr;
@@ -91006,8 +91152,8 @@ var init_dist84 = __esm({
                 const isEmptyDoc = this.editor.isEmpty;
                 doc3.descendants((node, pos) => {
                   const hasAnchor = anchor >= pos && anchor <= pos + node.nodeSize;
-                  const isEmpty2 = !node.isLeaf && isNodeEmpty(node);
-                  if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty2) {
+                  const isEmpty = !node.isLeaf && isNodeEmpty(node);
+                  if ((hasAnchor || !this.options.showOnlyCurrent) && isEmpty) {
                     const classes = [this.options.emptyNodeClass];
                     if (isEmptyDoc) {
                       classes.push(this.options.emptyEditorClass);
@@ -94234,7 +94380,7 @@ var init_dist86 = __esm({
 function RichTextEditorSurface({
   editor,
   config,
-  isEmpty: isEmpty2,
+  isEmpty,
   className,
   contentClassName,
   placeholderClassName,
@@ -94268,7 +94414,7 @@ function RichTextEditorSurface({
       onClick,
       ...interactiveContentProps,
       children: [
-        isEmpty2 ? /* @__PURE__ */ jsx(
+        isEmpty ? /* @__PURE__ */ jsx(
           "span",
           {
             className: cn2(
@@ -94514,7 +94660,7 @@ function useRichTextEditor({ content, editable, variant }) {
   const baseConfig = richTextConfigs[variant];
   const config = baseConfig;
   const [warnings, setWarnings] = useState({ unsupportedNodes: [], unsupportedMarks: [] });
-  const [isEmpty2, setIsEmpty] = useState(() => isDocEmpty(content));
+  const [isEmpty, setIsEmpty] = useState(() => isDocEmpty(content));
   const editor = useEditor2(
     {
       extensions: config.extensions,
@@ -94558,7 +94704,7 @@ function useRichTextEditor({ content, editable, variant }) {
     };
   }, [editor]);
   const warningSummary = hasUnsupportedRichTextContent(warnings) ? formatUnsupportedRichTextSummary(warnings) : null;
-  return { editor, isEmpty: isEmpty2, config, warnings, warningSummary };
+  return { editor, isEmpty, config, warnings, warningSummary };
 }
 function deepEqual4(a2, b3) {
   try {
@@ -96894,6 +97040,12 @@ var init_metadataConfig = __esm({
         "draftSlug",
         "draftStatus",
         "scheduledPublishAt"
+      ],
+      "team-member": [
+        "draftTitle",
+        "draftSlug",
+        "draftStatus",
+        "scheduledPublishAt"
       ]
     };
     EMPTY_METADATA_FIELDS = [];
@@ -97911,7 +98063,7 @@ function createRichTextDoc(paragraphs) {
     }))
   };
 }
-var EXCERPT_FALLBACK, SUMMARY_FALLBACK, BODY_TEXT_BINDINGS, DEFAULT_TEMPLATE_DEFINITIONS;
+var EXCERPT_FALLBACK, SUMMARY_FALLBACK, BODY_TEXT_BINDINGS, TEAM_MEMBER_BODY_TEXT_BINDINGS, DEFAULT_TEMPLATE_DEFINITIONS;
 var init_defaults2 = __esm({
   "../content-model/src/templates/defaults.ts"() {
     init_types3();
@@ -97933,6 +98085,10 @@ var init_defaults2 = __esm({
       body: fieldBinding("body"),
       alignment: literalBinding("left")
     };
+    TEAM_MEMBER_BODY_TEXT_BINDINGS = {
+      body: fieldBinding("bio"),
+      alignment: literalBinding("left")
+    };
     DEFAULT_TEMPLATE_DEFINITIONS = {
       post: {
         templateKey: "default",
@@ -98082,6 +98238,28 @@ var init_defaults2 = __esm({
           }
         ]
       },
+      "team-member": {
+        templateKey: "default",
+        name: "Team member profile",
+        description: "Default layout for team member profile pages.",
+        metadata: {},
+        blocks: [
+          {
+            blockKind: "block.hero",
+            scope: "entry",
+            bindings: {
+              eyebrow: literalBinding("About"),
+              headline: metaBinding("title"),
+              subheadline: fieldBinding("intro")
+            }
+          },
+          {
+            blockKind: "block.body-text",
+            scope: "entry",
+            bindings: TEAM_MEMBER_BODY_TEXT_BINDINGS
+          }
+        ]
+      },
       product: {
         templateKey: "default",
         name: "Product detail",
@@ -98339,19 +98517,65 @@ var init_fieldPath = __esm({
   "../blocks/src/system/manifest/fieldPath.ts"() {
   }
 });
-
-// ../blocks/src/system/manifest/registry.ts
-function registerManifest(manifest) {
-  manifestStore.set(manifest.name, manifest);
-  return manifest;
+function isInternalResolvedLinkValue(value) {
+  return value?.kind === "internal" && "entityId" in value && "entityType" in value && "href" in value && "title" in value && "typeLabel" in value && typeof value.entityId === "string" && typeof value.entityType === "string" && typeof value.href === "string" && typeof value.title === "string" && typeof value.typeLabel === "string";
 }
-var REGISTRY_SYMBOL, isVitest, globalScope, manifestStore;
-var init_registry2 = __esm({
-  "../blocks/src/system/manifest/registry.ts"() {
-    REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@riverbankcms/blocks/manifest-registry");
-    isVitest = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.VITEST === "true";
-    globalScope = globalThis;
-    manifestStore = isVitest ? /* @__PURE__ */ new Map() : globalScope[REGISTRY_SYMBOL] ?? (globalScope[REGISTRY_SYMBOL] = /* @__PURE__ */ new Map());
+var nullableString, resolvedInternalLinkKeys, internalRouteOnlyLinkSchema, internalResolvedLinkSchema, internalLinkSchema, externalLinkSchema, customLinkSchema, pageLinkSchema, entryLinkSchema, linkSchema;
+var init_link2 = __esm({
+  "../blocks/src/system/types/link.ts"() {
+    nullableString = z.union([z.string().min(1), z.null()]);
+    resolvedInternalLinkKeys = ["entityId", "entityType", "href", "title", "typeLabel"];
+    internalRouteOnlyLinkSchema = z.object({
+      kind: z.literal("internal"),
+      routeId: z.string().min(1)
+    }).passthrough().superRefine((value, ctx) => {
+      const hasResolvedMetadata = resolvedInternalLinkKeys.some((key) => value[key] != null);
+      if (!hasResolvedMetadata) return;
+      ctx.addIssue({
+        code: "custom",
+        message: "Internal links with resolved metadata must include entityId, entityType, href, title, and typeLabel"
+      });
+    });
+    internalResolvedLinkSchema = z.object({
+      kind: z.literal("internal"),
+      routeId: z.string().min(1),
+      entityId: z.string().min(1),
+      entityType: z.enum(["page", "content"]),
+      href: z.string().min(1),
+      title: z.string().min(1),
+      typeLabel: z.string().min(1),
+      contentTypeKey: nullableString.optional(),
+      contentTypeName: nullableString.optional(),
+      updatedAt: nullableString.optional()
+    }).passthrough();
+    internalLinkSchema = z.union([
+      internalResolvedLinkSchema,
+      internalRouteOnlyLinkSchema
+    ]);
+    externalLinkSchema = z.object({
+      kind: z.literal("external"),
+      href: z.string().min(1)
+    }).passthrough();
+    customLinkSchema = z.object({
+      kind: z.literal("url"),
+      href: z.string().min(1)
+    }).passthrough();
+    pageLinkSchema = z.object({
+      kind: z.literal("page"),
+      identifier: z.string().min(1)
+    }).passthrough();
+    entryLinkSchema = z.object({
+      kind: z.literal("entry"),
+      contentType: z.string().min(1),
+      identifier: z.string().min(1)
+    }).passthrough();
+    linkSchema = z.union([
+      internalLinkSchema,
+      externalLinkSchema,
+      customLinkSchema,
+      pageLinkSchema,
+      entryLinkSchema
+    ]);
   }
 });
 
@@ -100413,385 +100637,569 @@ var init_schema3 = __esm({
     });
   }
 });
-
-// ../blocks/src/lib/typeGuards.ts
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null;
+function assertNever5(value) {
+  throw new Error(`Unhandled field validation variant: ${JSON.stringify(value)}`);
 }
-var init_typeGuards2 = __esm({
-  "../blocks/src/lib/typeGuards.ts"() {
-  }
-});
-function buildRichTextSchema(options) {
-  let schema = RichTextValueSchema;
-  if (options?.required) {
-    const label = options.label ?? "This field";
-    schema = schema.refine(
-      (val) => {
-        const doc3 = isRecord5(val) && "doc" in val ? val.doc : val;
-        const content = isRecord5(doc3) ? doc3.content : void 0;
-        if (!Array.isArray(content) || content.length === 0) return false;
-        const first2 = content[0];
-        if (content.length === 1 && isRecord5(first2) && first2.type === "paragraph" && (!("content" in first2) || first2.content == null)) {
-          return false;
-        }
-        return true;
-      },
-      {
-        message: `${label} is required`
-      }
-    );
+function validationContext(options = {}) {
+  const isDraft = options.mode === "draft";
+  return {
+    allowNull: options.allowNull ?? true,
+    allowIncomplete: isDraft || (options.allowIncomplete ?? false)
+  };
+}
+function fieldIssueToMessage(issue2) {
+  switch (issue2.kind) {
+    case "required":
+      return "This field is required";
+    case "wrongType":
+      return `${issue2.label} needs ${issue2.expected}`;
+    case "tooLong":
+      return `Use ${issue2.maximum} characters or fewer`;
+    case "invalidEmail":
+      return "Enter a valid email address";
+    case "invalidPhone":
+      return "Enter a valid phone number";
+    case "invalidPattern":
+      return "Check the format and try again";
+    case "invalidUrl":
+      return "Enter a valid web address";
+    case "invalidNumber":
+      return `${issue2.label} needs a number`;
+    case "tooSmall":
+      return `${issue2.label} must be ${issue2.minimum} or more`;
+    case "tooLarge":
+      return `${issue2.label} must be ${issue2.maximum} or less`;
+    case "invalidSlug":
+      return `${issue2.label} can only use lowercase letters, numbers, and dashes`;
+    case "invalidOption":
+      return `Choose one of the available options for ${issue2.label}`;
+    case "tooFewItems":
+      return `${issue2.label} must have at least ${issue2.minimum} ${pluralize(issue2.itemLabel, issue2.minimum)}`;
+    case "tooManyItems":
+      return `${issue2.label} must have at most ${issue2.maximum} ${pluralize(issue2.itemLabel, issue2.maximum)}`;
+    case "invalidRichText":
+      return `${issue2.label} must be valid rich text`;
+    case "invalidMedia":
+      return `${issue2.label} must be a valid media item`;
+    case "invalidLink":
+      return `${issue2.label} must be a valid link`;
+    case "invalidReference":
+      return `${issue2.label} must reference a valid item`;
+    default:
+      return assertNever5(issue2);
   }
-  return schema;
 }
-var TipTapMarkSchema, TipTapNodeSchema, RichTextValueSchema;
-var init_richTextSchema = __esm({
-  "../blocks/src/system/manifest/richTextSchema.ts"() {
-    init_typeGuards2();
-    TipTapMarkSchema = z.object({
-      type: z.string(),
-      attrs: z.record(z.string(), z.unknown()).optional()
-    });
-    TipTapNodeSchema = z.lazy(
-      () => z.object({
-        type: z.string(),
-        content: z.array(TipTapNodeSchema).optional(),
-        text: z.string().optional(),
-        attrs: z.record(z.string(), z.unknown()).optional(),
-        marks: z.array(TipTapMarkSchema).optional()
-      })
-    );
-    RichTextValueSchema = z.union([
-      // New format: TipTap document directly
-      TipTapNodeSchema,
-      // Legacy format: wrapped in { doc: {...} }
-      z.object({
-        doc: TipTapNodeSchema
-      })
-    ]);
-  }
-});
-function isEmpty(value) {
-  if (typeof value === "string" && value.trim() === "") return true;
-  if (value === null || value === void 0) return true;
-  if (Array.isArray(value) && value.length === 0) return true;
-  if (isEmptyRichTextDoc(value)) return true;
-  return false;
+function pluralize(label, count3) {
+  if (count3 === 1) return label;
+  return label.endsWith("s") ? label : `${label}s`;
 }
-function isEmptyRichTextDoc(value) {
-  if (!value || typeof value !== "object") return false;
-  const obj = value;
-  const doc3 = "doc" in obj ? obj.doc : obj;
-  if (!doc3 || typeof doc3 !== "object") return false;
-  const docObj = doc3;
-  if (docObj.type !== "doc") return false;
-  const content = docObj.content;
-  if (!Array.isArray(content) || content.length === 0) return true;
-  if (content.length === 1) {
-    const first2 = content[0];
-    if (first2.type === "paragraph" && (!first2.content || first2.content.length === 0)) {
-      return true;
+function deriveFieldValidationPlan(field, path = [field.id]) {
+  const required = Boolean(field.required);
+  switch (field.type) {
+    case "text": {
+      const inputType = field.ui?.inputType;
+      if (inputType === "number") {
+        const constraints2 = commonConstraints(required, { kind: "numberType" });
+        if (typeof field.ui?.min === "number") constraints2.push({ kind: "numberMin", minimum: field.ui.min });
+        if (typeof field.ui?.max === "number") constraints2.push({ kind: "numberMax", maximum: field.ui.max });
+        return makePlan("number", "number", field, path, required, constraints2);
+      }
+      const constraints = commonConstraints(required, { kind: "textType" });
+      if (inputType === "email") constraints.push({ kind: "emailFormat" });
+      if (inputType === "tel") constraints.push({ kind: "phoneFormat" });
+      if (field.ui?.pattern) constraints.push({ kind: "patternFormat", pattern: field.ui.pattern });
+      if (typeof field.maxLength === "number") constraints.push({ kind: "maxLength", maximum: field.maxLength });
+      return makePlan("string", "string", field, path, required, constraints);
+    }
+    case "number": {
+      const constraints = commonConstraints(required, { kind: "numberType" });
+      if (typeof field.min === "number") constraints.push({ kind: "numberMin", minimum: field.min });
+      if (typeof field.max === "number") constraints.push({ kind: "numberMax", maximum: field.max });
+      return makePlan("number", "number", field, path, required, constraints);
+    }
+    case "slug": {
+      const constraints = commonConstraints(required, { kind: "textType" }, { kind: "slugFormat" });
+      if (typeof field.maxLength === "number") constraints.push({ kind: "maxLength", maximum: field.maxLength });
+      return makePlan("string", "string", field, path, required, constraints);
     }
+    case "url":
+      return makePlan("string", "string", field, path, required, commonConstraints(
+        required,
+        { kind: "textType" },
+        { kind: "urlFormat", allowRelative: Boolean(field.allowRelative) }
+      ));
+    case "reference":
+      return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "referenceText" }));
+    case "date":
+    case "time":
+    case "datetime":
+      return makePlan("string", "string", field, path, required, commonConstraints(required, { kind: "textType" }));
+    case "select":
+      return makePlan("select", "select", field, path, required, commonConstraints(required, {
+        kind: "selectOption",
+        source: resolveSelectConstraintSource(field),
+        multiple: Boolean(field.multiple)
+      }));
+    case "richText":
+      return makePlan("richText", "object", field, path, required, commonConstraints(required, { kind: "richTextDoc" }));
+    case "media":
+      return makePlan("media", "object", field, path, required, commonConstraints(required, { kind: "mediaObject" }));
+    case "link":
+      return makePlan("link", "object", field, path, required, commonConstraints(required, { kind: "linkObject" }));
+    case "boolean":
+      return makePlan("boolean", "boolean", field, path, required, requiredConstraints(required));
+    case "repeater":
+      return {
+        ...makePlan("repeater", "array", field, path, required, commonConstraints(required, { kind: "arrayType" })),
+        ...field.polymorphic && field.itemTypes ? { repeatedItemVariants: deriveRepeatedItemVariants(field, [...path, 0]) } : { repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path, 0]) },
+        constraints: withRepeaterItemConstraints(field, commonConstraints(required, { kind: "arrayType" }))
+      };
+    case "group":
+    case "modal":
+      return {
+        ...makePlan("group", "object", field, path, required, requiredConstraints(required)),
+        children: deriveNestedFieldPlans(field.schema?.fields ?? [], path),
+        allowNullChildren: field.type === "group" && field.ui?.widget === "locationPicker"
+      };
+    case "tabGroup":
+      return {
+        ...makePlan("group", "object", field, path, required, requiredConstraints(required)),
+        children: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path))
+      };
+    case "presetOrCustom":
+    case "contentTypeSelect":
+    case "entryPicker":
+      return makePlan("passthrough", "unknown", field, path, false, []);
+    default:
+      return assertNever5(field);
   }
-  return false;
 }
-function preprocessEmptyValues(content) {
-  if (!content || typeof content !== "object" || Array.isArray(content)) {
-    return {};
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(content)) {
-    result[key] = isEmpty(value) ? void 0 : value;
+function commonConstraints(required, ...specific) {
+  return required ? [{ kind: "required" }, ...specific] : [...specific];
+}
+function requiredConstraints(required) {
+  return required ? [{ kind: "required" }] : [];
+}
+function makePlan(kind, valueKind, field, path, required, constraints) {
+  return {
+    kind,
+    valueKind,
+    fieldId: field.id,
+    label: field.label,
+    fieldType: field.type,
+    path,
+    required,
+    constraints
+  };
+}
+function withRepeaterItemConstraints(field, constraints) {
+  const next = [...constraints];
+  if (typeof field.minItems === "number") next.push({ kind: "minItems", minimum: field.minItems });
+  if (typeof field.maxItems === "number") next.push({ kind: "maxItems", maximum: field.maxItems });
+  return next;
+}
+function deriveRepeatedItemVariants(field, parentPath) {
+  return Object.entries(field.itemTypes ?? {}).map(([typeId, itemType]) => ({
+    typeId,
+    fields: deriveNestedFieldPlans(getFlattenedRepeaterFields(itemType.fields), parentPath)
+  }));
+}
+function deriveNestedFieldPlans(fields3, parentPath) {
+  return fields3.map((field) => deriveFieldValidationPlan(field, [...parentPath, field.id]));
+}
+function getRepeaterFields(field) {
+  const fields3 = field.polymorphic && field.itemTypes ? Object.values(field.itemTypes).flatMap((itemType) => itemType.fields) : field.schema?.fields ?? [];
+  return getFlattenedRepeaterFields(fields3);
+}
+function getFlattenedRepeaterFields(fields3) {
+  return fields3.flatMap((child) => {
+    if (child.type === "group" && child.ui?.flattenInRepeater) {
+      return child.schema?.fields ?? [];
+    }
+    return child;
+  });
+}
+function resolveSelectConstraintSource(field) {
+  const source = normalizeSelectSource(field);
+  switch (source.kind) {
+    case "static":
+      return { kind: "static", values: field.options.map((option) => option.value) };
+    case "site":
+    case "sdk":
+      return { kind: "runtime", source: source.kind };
+    default:
+      return assertNever5(source);
   }
-  return result;
 }
-function createManifestValidator(manifestOrFields, options = {}) {
-  const allowNull = options.allowNull ?? true;
-  const isDraft = options.mode === "draft";
-  const allowIncomplete = isDraft || (options.allowIncomplete ?? false);
-  const shape = {};
-  const fields3 = Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? [];
-  for (const field of fields3) {
-    shape[field.id] = buildFieldSchema(field, allowNull, allowIncomplete);
+function normalizeFieldValue(plan, value, ctx) {
+  switch (plan.kind) {
+    case "number":
+      return normalizeNumberInput(value, ctx.allowNull);
+    case "string":
+      return acceptsOptionalBlankAsMissing(plan, value) ? void 0 : value;
+    case "group":
+      return normalizeObjectChildren(plan.children, value, childValidationContext(plan, ctx));
+    case "repeater":
+      return normalizeRepeaterItems(plan, value, ctx);
+    case "boolean":
+    case "richText":
+    case "media":
+    case "link":
+    case "select":
+    case "passthrough":
+      return value;
+    default:
+      return assertNever5(plan);
   }
-  const baseSchema = z.object(shape).catchall(z.unknown()).passthrough();
-  if (isDraft) {
-    return z.preprocess(preprocessEmptyValues, baseSchema);
+}
+function normalizeObjectChildren(children, value, ctx) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const normalized = { ...value };
+  for (const child of children) {
+    normalized[child.fieldId] = normalizeFieldValue(child, normalized[child.fieldId], ctx);
   }
-  return baseSchema;
+  return normalized;
 }
-function buildFieldSchema(field, allowNull, allowIncomplete = false) {
-  const required = Boolean(field.required);
-  let schema;
-  switch (field.type) {
-    case "text":
-      schema = buildTextSchema(field);
-      break;
-    case "richText":
-      schema = buildRichTextSchema2();
-      break;
-    case "media": {
-      const baseMediaSchema = z.record(z.string(), z.unknown());
-      const isRequired = Boolean(field.required);
-      schema = isRequired ? baseMediaSchema : baseMediaSchema.nullable();
-      break;
-    }
+function normalizeRepeaterItems(plan, value, ctx) {
+  if (!Array.isArray(value)) return value;
+  return value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+    const itemRecord = item;
+    const fields3 = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemRecord._type)?.fields : plan.repeatedItemPlan;
+    if (!fields3) return item;
+    return normalizeObjectChildren(fields3, itemRecord, ctx);
+  });
+}
+function normalizeNumberInput(value, allowNull) {
+  if (value === "") return void 0;
+  if (typeof value === "string" && value.trim() !== "") return Number(value);
+  return value;
+}
+function acceptsOptionalBlankAsMissing(plan, value) {
+  if (plan.required || typeof value !== "string" || value.trim() !== "") return false;
+  return plan.constraints.some(
+    (constraint) => constraint.kind === "urlFormat" || constraint.kind === "slugFormat" || constraint.kind === "emailFormat" || constraint.kind === "phoneFormat" || constraint.kind === "patternFormat"
+  );
+}
+function validateNormalizedFieldValue(plan, value, ctx) {
+  if (value === null && (ctx.allowNull || acceptsOptionalNullValue(plan))) return [];
+  if (isMissingForPlan(plan, value)) {
+    return shouldRequireValue(plan, value, ctx) ? [requiredIssue(plan, value)] : [];
+  }
+  switch (plan.kind) {
+    case "string":
+      return validateStringPlan(plan, value);
+    case "number":
+      return validateNumberPlan(plan, value);
     case "boolean":
-      schema = z.boolean();
-      break;
-    case "slug":
-      schema = buildSlugSchema(field);
-      break;
-    case "url":
-      schema = buildUrlSchema(field);
-      break;
-    case "link":
-      schema = buildLinkSchema();
-      break;
+      return typeof value === "boolean" ? [] : [issue(plan, "wrongType", { expected: "a true/false value" })];
     case "select":
-      schema = buildSelectSchema(field);
-      break;
-    case "reference":
-      schema = buildReferenceSchema(field);
-      break;
+      return validateSelectPlan(plan, value);
+    case "richText":
+      return isValidRichTextDoc(value) ? [] : [issue(plan, "invalidRichText")];
+    case "media":
+      return isPlainObject3(value) ? [] : [issue(plan, "invalidMedia")];
+    case "link":
+      return linkSchema.safeParse(value).success ? [] : [issue(plan, "invalidLink")];
     case "repeater":
-      schema = buildRepeaterSchema(field, allowNull, allowIncomplete);
-      break;
+      return validateRepeaterPlan(plan, value, ctx);
     case "group":
-      schema = buildGroupSchema(field, allowNull, allowIncomplete);
-      break;
+      return validateGroupPlan(plan, value, ctx);
+    case "passthrough":
+      return [];
     default:
-      schema = z.unknown();
-      break;
+      return assertNever5(plan);
   }
-  return finalizeSchema(schema, required, allowNull, allowIncomplete);
 }
-function buildFriendlyStringSchema(field) {
-  return z.string({
-    error: (issue) => issue.input === void 0 || issue.input === null ? "This field is required" : `${field.label} needs text`
-  });
+function shouldRequireValue(plan, value, ctx) {
+  if (!plan.required || ctx.allowIncomplete) return false;
+  if (value === null && ctx.allowNull) return false;
+  return true;
 }
-function buildTextSchema(field) {
-  const ui = field.ui ?? {};
-  const inputType = ui?.inputType;
-  let schema;
-  if (inputType === "number") {
-    schema = z.coerce.number({
-      error: (issue) => issue.input === void 0 ? `${field.label} is required` : `${field.label} needs a number`
-    });
-    if (typeof ui?.min === "number") {
-      schema = schema.min(
-        ui.min,
-        `${field.label} must be ${ui.min} or more`
-      );
-    }
-    if (typeof ui?.max === "number") {
-      schema = schema.max(
-        ui.max,
-        `${field.label} must be ${ui.max} or less`
-      );
-    }
-  } else {
-    schema = buildFriendlyStringSchema(field);
-    if (inputType === "email") {
-      schema = schema.email("Enter a valid email address");
-    }
-    if (inputType === "tel") {
-      const TEL_RE = /^[+()0-9\s\-]{3,}$/;
-      schema = schema.regex(
-        TEL_RE,
-        "Enter a valid phone number"
-      );
-    }
-    if (ui?.pattern) {
-      try {
-        const re2 = new RegExp(ui.pattern);
-        schema = schema.regex(
-          re2,
-          `${field.label} is not in the right format`
-        );
-      } catch {
-      }
-    }
-    if (field.maxLength) {
-      schema = schema.max(
-        field.maxLength,
-        `${field.label} must be ${field.maxLength} characters or less`
-      );
-    }
-    if (field.required) {
-      schema = schema.min(1, { message: `${field.label} is required` }).refine((v2) => v2.trim().length > 0, { message: `${field.label} is required` });
-    }
-  }
-  return schema;
+function acceptsOptionalNullValue(plan) {
+  return !plan.required && (plan.kind === "media" || plan.kind === "number");
+}
+function isMissingForPlan(plan, value) {
+  if (value === void 0) return true;
+  if (value === null) return plan.required;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
 }
-function buildRichTextSchema2() {
-  return buildRichTextSchema();
+function validateStringPlan(plan, value) {
+  if (typeof value !== "string") return [issue(plan, "wrongType", { expected: "text" })];
+  return plan.constraints.flatMap((constraint) => validateStringConstraint(plan, constraint, value));
 }
-function buildSlugSchema(field) {
-  const message2 = `${field.label} can only use lowercase letters, numbers, and dashes`;
-  let schema = buildFriendlyStringSchema(field).regex(SLUG_PATTERN, message2);
-  if (field.maxLength) {
-    schema = schema.max(
-      field.maxLength,
-      `${field.label} must be ${field.maxLength} characters or less`
-    );
+function validateStringConstraint(plan, constraint, value) {
+  switch (constraint.kind) {
+    case "required":
+    case "textType":
+    case "referenceText":
+      return [];
+    case "maxLength":
+      return value.length > constraint.maximum ? [issue(plan, "tooLong", { maximum: constraint.maximum })] : [];
+    case "emailFormat":
+      return z.email().safeParse(value).success ? [] : [issue(plan, "invalidEmail")];
+    case "phoneFormat":
+      return TEL_RE.test(value) ? [] : [issue(plan, "invalidPhone")];
+    case "patternFormat": {
+      const re2 = compilePattern(constraint.pattern);
+      return re2 && !re2.test(value) ? [issue(plan, "invalidPattern")] : [];
+    }
+    case "urlFormat":
+      return isValidUrl(value, constraint.allowRelative) ? [] : [issue(plan, "invalidUrl")];
+    case "slugFormat":
+      return SLUG_PATTERN.test(value) ? [] : [issue(plan, "invalidSlug")];
+    default:
+      return assertNever5(constraint);
   }
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
+}
+function validateNumberPlan(plan, value) {
+  if (!isValidNumber(value)) return [issue(plan, "invalidNumber")];
+  return plan.constraints.flatMap((constraint) => validateNumberConstraint(plan, constraint, Number(value)));
+}
+function validateNumberConstraint(plan, constraint, value) {
+  switch (constraint.kind) {
+    case "required":
+    case "numberType":
+      return [];
+    case "numberMin":
+      return value < constraint.minimum ? [issue(plan, "tooSmall", { minimum: constraint.minimum })] : [];
+    case "numberMax":
+      return value > constraint.maximum ? [issue(plan, "tooLarge", { maximum: constraint.maximum })] : [];
+    default:
+      return assertNever5(constraint);
   }
-  return schema;
 }
-function buildUrlSchema(field) {
-  const message2 = "Enter a valid web address";
-  const validate = (value) => {
-    if (!value) {
-      return !field.required;
-    }
-    if (field.allowRelative && value.startsWith("/")) {
-      return true;
-    }
-    try {
-      const parsed = new URL(value);
-      return ALLOWED_URL_PROTOCOLS.includes(
-        parsed.protocol
-      );
-    } catch {
-      return false;
+function validateSelectPlan(plan, value) {
+  const constraint = plan.constraints.find((candidate) => candidate.kind === "selectOption");
+  if (!constraint || constraint.source.kind === "runtime") return [];
+  return isValidSelectValue(value, constraint.source.values, constraint.multiple) ? [] : [issue(plan, "invalidOption")];
+}
+function validateRepeaterPlan(plan, value, ctx) {
+  if (!Array.isArray(value)) return [issue(plan, "wrongType", { expected: "a list" })];
+  const constraintIssues = plan.constraints.flatMap((constraint) => {
+    switch (constraint.kind) {
+      case "required":
+      case "arrayType":
+        return [];
+      case "minItems":
+        return value.length < constraint.minimum ? [issue(plan, "tooFewItems", { minimum: constraint.minimum, itemLabel: "item" })] : [];
+      case "maxItems":
+        return value.length > constraint.maximum ? [issue(plan, "tooManyItems", { maximum: constraint.maximum, itemLabel: "item" })] : [];
+      default:
+        return assertNever5(constraint);
     }
+  });
+  return [
+    ...constraintIssues,
+    ...value.flatMap((item, index2) => validateRepeaterItem(plan, item, index2, ctx))
+  ];
+}
+function validateRepeaterItem(plan, item, index2, ctx) {
+  if (!isPlainObject3(item)) return [];
+  const itemType = item._type;
+  const fields3 = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemType)?.fields : plan.repeatedItemPlan;
+  if (!fields3) return [];
+  return fields3.flatMap((childPlan) => {
+    const indexedPlan = withIndexedPath(childPlan, plan.path, index2);
+    return validateNormalizedFieldValue(indexedPlan, item[childPlan.fieldId], ctx);
+  });
+}
+function validateGroupPlan(plan, value, ctx) {
+  if (!isPlainObject3(value)) return [issue(plan, "wrongType", { expected: "an object" })];
+  const childCtx = childValidationContext(plan, ctx);
+  return plan.children.flatMap((childPlan) => validateNormalizedFieldValue(childPlan, value[childPlan.fieldId], childCtx));
+}
+function childValidationContext(plan, ctx) {
+  return plan.allowNullChildren ? { ...ctx, allowNull: true } : ctx;
+}
+function withIndexedPath(plan, parentPath, index2) {
+  const suffix = plan.path.slice(parentPath.length + 1);
+  return {
+    ...plan,
+    path: [...parentPath, index2, plan.fieldId, ...suffix]
   };
-  let schema = buildFriendlyStringSchema(field).trim().refine(validate, message2);
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
-  }
-  return schema;
 }
-function buildLinkSchema() {
-  return linkSchema;
+function issue(plan, kind, extra) {
+  return {
+    kind,
+    path: plan.path,
+    fieldId: plan.fieldId,
+    label: plan.label,
+    ...extra ?? {}
+  };
 }
-function assertNeverSelectSource2(value) {
-  throw new Error(`Unhandled select source: ${JSON.stringify(value)}`);
+function requiredIssue(plan, value) {
+  if (typeof value === "string") return issue(plan, "required", { emptyOrigin: "string" });
+  if (Array.isArray(value)) return issue(plan, "required", { emptyOrigin: "array" });
+  return issue(plan, "required");
 }
-function buildSelectSchema(field) {
-  const source = normalizeSelectSource(field);
-  const singleValueSchema = (() => {
-    switch (source.kind) {
-      case "sdk":
-      case "site":
-        return buildFriendlyStringSchema(field);
-      case "static": {
-        const values = field.options.map((option) => option.value);
-        return buildFriendlyStringSchema(field).refine(
-          (value) => values.includes(value),
-          `Choose one of the available options for ${field.label}`
-        );
-      }
-      default:
-        return assertNeverSelectSource2(source);
+function fieldPlanToZod(plan, options = {}) {
+  const ctx = validationContext(options);
+  return z.any().transform((value) => normalizeFieldValue(plan, value, ctx)).superRefine((value, zodCtx) => {
+    for (const validationIssue of validateNormalizedFieldValue(plan, value, ctx)) {
+      addFieldIssueToZodContext(zodCtx, validationIssue);
     }
-  })();
-  if (field.multiple) {
-    const arraySchema = z.array(singleValueSchema);
-    return field.required ? arraySchema.min(1, { message: "This field is required" }) : arraySchema.nullable();
+  });
+}
+function addFieldIssueToZodContext(zodCtx, validationIssue) {
+  const message2 = fieldIssueToMessage(validationIssue);
+  switch (validationIssue.kind) {
+    case "required":
+      if (validationIssue.emptyOrigin) {
+        zodCtx.addIssue({
+          code: "too_small",
+          origin: validationIssue.emptyOrigin,
+          minimum: 1,
+          inclusive: true,
+          message: message2
+        });
+        return;
+      }
+      zodCtx.addIssue({ code: "invalid_type", expected: "nonoptional", message: message2 });
+      return;
+    case "tooLong":
+      zodCtx.addIssue({
+        code: "too_big",
+        origin: "string",
+        maximum: validationIssue.maximum,
+        inclusive: true,
+        message: message2
+      });
+      return;
+    case "invalidOption":
+      zodCtx.addIssue({ code: "invalid_value", values: [], message: message2 });
+      return;
+    case "wrongType":
+    case "invalidEmail":
+    case "invalidPhone":
+    case "invalidPattern":
+    case "invalidUrl":
+    case "invalidNumber":
+    case "tooSmall":
+    case "tooLarge":
+    case "invalidSlug":
+    case "tooFewItems":
+    case "tooManyItems":
+    case "invalidRichText":
+    case "invalidMedia":
+    case "invalidLink":
+    case "invalidReference":
+      zodCtx.addIssue({ code: "custom", message: message2 });
+      return;
+    default:
+      assertNever5(validationIssue);
   }
-  return field.required ? singleValueSchema : singleValueSchema.nullable();
 }
-function buildReferenceSchema(field) {
-  let schema = z.string({
-    error: (issue) => issue.input === void 0 || issue.input === null ? "This field is required" : `${field.label} needs text`
-  });
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return null;
   }
-  return schema;
 }
-function buildRepeaterSchema(field, allowNull, allowIncomplete) {
-  const parsed = fieldSchema.array().parse(field.schema?.fields ?? []);
-  const childShape = {};
-  for (const child of parsed) {
-    if (child.type === "group" && child.ui?.flattenInRepeater) {
-      const groupParsed = fieldSchema.array().parse(child.schema?.fields ?? []);
-      for (const gc of groupParsed) {
-        childShape[gc.id] = buildFieldSchema(gc, allowNull, allowIncomplete);
-      }
-    } else {
-      childShape[child.id] = buildFieldSchema(child, allowNull, allowIncomplete);
-    }
+function isValidNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isValidUrl(value, allowRelative) {
+  if (!value) return false;
+  if (allowRelative && value.startsWith("/")) return true;
+  try {
+    const parsed = new URL(value);
+    return ALLOWED_URL_PROTOCOLS.includes(parsed.protocol);
+  } catch {
+    return false;
   }
-  let schema = z.object(childShape).catchall(z.unknown()).passthrough();
-  let arraySchema = z.array(schema);
-  if (typeof field.minItems === "number") {
-    arraySchema = arraySchema.min(field.minItems);
+}
+function isValidSelectValue(value, values, multiple) {
+  if (multiple) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string" && values.includes(item));
   }
-  if (typeof field.maxItems === "number") {
-    arraySchema = arraySchema.max(field.maxItems);
+  return typeof value === "string" && values.includes(value);
+}
+function isEmptyValue(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  if (isEmptyRichTextDoc(value)) return true;
+  return false;
+}
+function isPlainObject3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isValidRichTextDoc(value) {
+  const doc3 = richTextDoc(value);
+  return Boolean(isPlainObject3(doc3) && doc3.type === "doc");
+}
+function isEmptyRichTextDoc(value) {
+  const doc3 = richTextDoc(value);
+  if (!isPlainObject3(doc3)) return false;
+  if (doc3.type !== "doc") return false;
+  const content = doc3.content;
+  if (!Array.isArray(content) || content.length === 0) return true;
+  if (content.length !== 1) return false;
+  const first2 = content[0];
+  return first2?.type === "paragraph" && (!Array.isArray(first2.content) || first2.content.length === 0);
+}
+function richTextDoc(value) {
+  if (!isPlainObject3(value)) return value;
+  return isPlainObject3(value.doc) ? value.doc : value;
+}
+var TEL_RE, SLUG_PATTERN, ALLOWED_URL_PROTOCOLS;
+var init_fieldValidation = __esm({
+  "../blocks/src/system/manifest/fieldValidation/index.ts"() {
+    init_link2();
+    init_schema3();
+    TEL_RE = /^[+()0-9\s-]{3,}$/;
+    SLUG_PATTERN = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
+    ALLOWED_URL_PROTOCOLS = ["http:", "https:"];
   }
-  return arraySchema;
+});
+
+// ../blocks/src/system/manifest/registry.ts
+function registerManifest(manifest) {
+  manifestStore.set(manifest.name, manifest);
+  return manifest;
 }
-function buildGroupSchema(field, allowNull, allowIncomplete) {
-  const parsed = fieldSchema.array().parse(field.schema?.fields ?? []);
-  const childShape = {};
-  for (const child of parsed) {
-    childShape[child.id] = buildFieldSchema(child, allowNull, allowIncomplete);
+var REGISTRY_SYMBOL, isVitest, globalScope, manifestStore;
+var init_registry2 = __esm({
+  "../blocks/src/system/manifest/registry.ts"() {
+    REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@riverbankcms/blocks/manifest-registry");
+    isVitest = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.VITEST === "true";
+    globalScope = globalThis;
+    manifestStore = isVitest ? /* @__PURE__ */ new Map() : globalScope[REGISTRY_SYMBOL] ?? (globalScope[REGISTRY_SYMBOL] = /* @__PURE__ */ new Map());
   }
-  return z.object(childShape).catchall(z.unknown()).passthrough();
+});
+function preprocessEmptyValues(content) {
+  if (!content || typeof content !== "object" || Array.isArray(content)) {
+    return {};
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(content)) {
+    result[key] = isEmptyValue(value) ? void 0 : value;
+  }
+  return result;
 }
-function finalizeSchema(schema, required, allowNull, allowIncomplete = false) {
-  if (required) {
-    if (allowIncomplete) {
-      return allowNull ? schema.or(z.null()).optional() : schema.optional();
-    }
-    return allowNull ? schema.or(z.null()) : schema;
+function createManifestValidator(manifestOrFields, options = {}) {
+  const isDraft = options.mode === "draft";
+  const shape = {};
+  const fields3 = Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? [];
+  for (const field of fields3) {
+    shape[field.id] = buildFieldSchema(field, options);
+  }
+  const baseSchema = z.object(shape).catchall(z.unknown()).passthrough();
+  if (isDraft) {
+    return z.preprocess(preprocessEmptyValues, baseSchema);
   }
-  return allowNull ? schema.optional().nullable() : schema.optional();
+  return baseSchema;
+}
+function buildFieldSchema(field, options) {
+  return fieldPlanToZod(deriveFieldValidationPlan(field), options);
 }
-var SLUG_PATTERN, ALLOWED_URL_PROTOCOLS, nullableString, internalLinkSchema, externalLinkSchema, customLinkSchema, pageLinkSchema, entryLinkSchema, linkSchema;
 var init_validation = __esm({
   "../blocks/src/system/manifest/validation.ts"() {
-    init_schema3();
-    init_richTextSchema();
-    SLUG_PATTERN = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
-    ALLOWED_URL_PROTOCOLS = ["http:", "https:"];
-    nullableString = z.union([z.string().min(1), z.null()]);
-    internalLinkSchema = z.object({
-      kind: z.literal("internal"),
-      routeId: z.string().min(1),
-      entityId: z.string().min(1).optional(),
-      entityType: z.enum(["page", "content"]).optional(),
-      href: nullableString.optional(),
-      title: nullableString.optional(),
-      typeLabel: nullableString.optional(),
-      contentTypeKey: nullableString.optional(),
-      contentTypeName: nullableString.optional(),
-      updatedAt: nullableString.optional()
-    }).passthrough();
-    externalLinkSchema = z.object({
-      kind: z.literal("external"),
-      href: z.string().min(1)
-    }).passthrough();
-    customLinkSchema = z.object({
-      kind: z.literal("url"),
-      href: z.string().min(1)
-    }).passthrough();
-    pageLinkSchema = z.object({
-      kind: z.literal("page"),
-      identifier: z.string().min(1)
-    }).passthrough();
-    entryLinkSchema = z.object({
-      kind: z.literal("entry"),
-      contentType: z.string().min(1),
-      identifier: z.string().min(1)
-    }).passthrough();
-    linkSchema = z.union([
-      internalLinkSchema,
-      externalLinkSchema,
-      customLinkSchema,
-      pageLinkSchema,
-      entryLinkSchema
-    ]);
+    init_fieldValidation();
   }
 });
 
@@ -100828,6 +101236,7 @@ var init_manifest = __esm({
   "../blocks/src/system/manifest/index.ts"() {
     init_augmentManifest();
     init_fieldPath();
+    init_fieldValidation();
     init_registry2();
     init_schema3();
     init_validation();
@@ -100894,7 +101303,7 @@ function makeBoundaryId(previousBlockId, nextBlockId) {
   const next = encodeURIComponent(nextBlockId);
   return asDesignBoundaryId(`boundary:${previous}:${next}`);
 }
-function assertNever5(value, message2 = "Unhandled Theme V2 variant") {
+function assertNever6(value, message2 = "Unhandled Theme V2 variant") {
   throw new Error(`${message2}: ${String(value)}`);
 }
 function brandNonEmptyString(value, label) {
@@ -101999,44 +102408,44 @@ var init_personalities = __esm({
 var hotspotSchema, rotationSchema, rectSchema, aspectCropSchema, transformSchema, mediaSchema;
 var init_media = __esm({
   "../theme-core/src/lib/media.ts"() {
-    hotspotSchema = z37.object({
-      x: z37.number().min(0).max(1),
-      y: z37.number().min(0).max(1),
-      radius: z37.number().optional()
-    });
-    rotationSchema = z37.union([z37.literal(0), z37.literal(90), z37.literal(180), z37.literal(270)]);
-    rectSchema = z37.tuple([z37.number(), z37.number(), z37.number(), z37.number()]);
-    aspectCropSchema = z37.object({
-      aspect: z37.preprocess((value) => value == null ? void 0 : value, z37.string().optional()),
-      rect: z37.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
-      hotspot: z37.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
-      rotation: z37.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
-    });
-    transformSchema = z37.object({
-      aspectCrops: z37.preprocess((value) => {
+    hotspotSchema = z38.object({
+      x: z38.number().min(0).max(1),
+      y: z38.number().min(0).max(1),
+      radius: z38.number().optional()
+    });
+    rotationSchema = z38.union([z38.literal(0), z38.literal(90), z38.literal(180), z38.literal(270)]);
+    rectSchema = z38.tuple([z38.number(), z38.number(), z38.number(), z38.number()]);
+    aspectCropSchema = z38.object({
+      aspect: z38.preprocess((value) => value == null ? void 0 : value, z38.string().optional()),
+      rect: z38.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
+      hotspot: z38.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
+      rotation: z38.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
+    });
+    transformSchema = z38.object({
+      aspectCrops: z38.preprocess((value) => {
         if (!value || typeof value !== "object" || Array.isArray(value)) {
           return void 0;
         }
         return value;
-      }, z37.record(z37.string(), aspectCropSchema.catch({}))).optional(),
+      }, z38.record(z38.string(), aspectCropSchema.catch({}))).optional(),
       rect: rectSchema.optional(),
       hotspot: hotspotSchema.optional(),
       rotation: rotationSchema.optional()
     });
-    mediaSchema = z37.object({
-      type: z37.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-      purpose: z37.string().optional(),
-      placeholder: z37.boolean().default(true).optional(),
-      assetId: z37.string().optional(),
-      identifier: z37.string().optional(),
-      src: z37.string().optional(),
-      alt: z37.string().optional(),
-      filename: z37.string().optional(),
-      mimeType: z37.string().optional(),
-      width: z37.number().optional(),
-      height: z37.number().optional(),
-      storageBucket: z37.string().optional(),
-      storagePath: z37.string().optional(),
+    mediaSchema = z38.object({
+      type: z38.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
+      purpose: z38.string().optional(),
+      placeholder: z38.boolean().default(true).optional(),
+      assetId: z38.string().optional(),
+      identifier: z38.string().optional(),
+      src: z38.string().optional(),
+      alt: z38.string().optional(),
+      filename: z38.string().optional(),
+      mimeType: z38.string().optional(),
+      width: z38.number().optional(),
+      height: z38.number().optional(),
+      storageBucket: z38.string().optional(),
+      storagePath: z38.string().optional(),
       transform: transformSchema.optional()
     });
   }
@@ -106622,7 +107031,7 @@ function compileContainerStyles(contentFrame, rules) {
         })
       };
     default:
-      return assertNever5(contentFrame);
+      return assertNever6(contentFrame);
   }
 }
 function compileBlockRuntimeFields(input) {
@@ -107006,8 +107415,8 @@ var init_generatedDesignPipeline = __esm({
   }
 });
 function validateBlockSequence(snapshots, ctx) {
-  for (const issue of collectBlockSequenceIssues(snapshots)) {
-    ctx.addIssue(issue);
+  for (const issue2 of collectBlockSequenceIssues(snapshots)) {
+    ctx.addIssue(issue2);
   }
 }
 function collectBlockSequenceIssues(snapshots) {
@@ -112674,7 +113083,19 @@ var init_teamMember = __esm({
               bind2("photo")
             )
           ]),
-          text({ as: "h3" }, bind2("name")),
+          link(
+            {
+              href: { $bind: { from: "profilePath" } },
+              className: "rb-team-member-name-link"
+            },
+            [text({ as: "h3" }, bind2("name"))],
+            when("profilePath")
+          ),
+          text(
+            { as: "h3" },
+            when("profilePath", { not: true }),
+            bind2("name")
+          ),
           text({ as: "p", className: "rb-team-member-role" }, when("role"), bind2("role")),
           richText(
             { className: "rb-prose rb-max-w-none" },
@@ -113551,9 +113972,9 @@ function createZodCodec(schema) {
         return decodeSuccess(parsed.data);
       }
       return decodeFailure(
-        parsed.error.issues.map((issue) => ({
-          path: zodIssuePath(issue.path),
-          message: issue.message
+        parsed.error.issues.map((issue2) => ({
+          path: zodIssuePath(issue2.path),
+          message: issue2.message
         }))
       );
     }
@@ -113961,7 +114382,7 @@ function getNavStyleClasses(navStyle) {
       return baseClasses;
   }
 }
-function isPlainObject3(value) {
+function isPlainObject4(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readString(obj, key) {
@@ -114089,7 +114510,7 @@ var init_ui = __esm({
       summary: "Resolve hero content wrapper className from alignment + max width controls",
       schema: heroContentWrapperClassSchema,
       run: (value, options, context) => {
-        const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
+        const content = isPlainObject4(value) ? value : isPlainObject4(context.data) ? context.data : {};
         const alignment = resolveHeroContentAlignment(content);
         const maxWidth = resolveHeroContentMaxWidth(content);
         const textAlignClass = alignment === "center" ? "rb-text-center" : alignment === "right" ? "rb-text-right" : "rb-text-left";
@@ -114108,7 +114529,7 @@ var init_ui = __esm({
       kind: "string",
       summary: "Map hero contentAlignment to CTA row justify value",
       run: (value, _options, context) => {
-        const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
+        const content = isPlainObject4(value) ? value : isPlainObject4(context.data) ? context.data : {};
         const alignment = resolveHeroContentAlignment(content);
         return alignment === "left" ? "start" : alignment === "right" ? "end" : "center";
       }
@@ -114118,7 +114539,7 @@ var init_ui = __esm({
       kind: "string",
       summary: "Map hero verticalAlignment to stack justify value",
       run: (value, _options, context) => {
-        const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
+        const content = isPlainObject4(value) ? value : isPlainObject4(context.data) ? context.data : {};
         const vertical = resolveHeroVerticalAlignment(content);
         return vertical === "top" ? "start" : vertical === "bottom" ? "end" : "center";
       }
@@ -114132,7 +114553,7 @@ var init_ui = __esm({
       summary: "Append align-items class for hero split layouts based on verticalAlignment",
       schema: heroGridClassFromVerticalAlignmentSchema,
       run: (value, options, context) => {
-        const content = isPlainObject3(value) ? value : isPlainObject3(context.data) ? context.data : {};
+        const content = isPlainObject4(value) ? value : isPlainObject4(context.data) ? context.data : {};
         const vertical = resolveHeroVerticalAlignment(content);
         const itemsClass = vertical === "top" ? "rb-items-start" : vertical === "bottom" ? "rb-items-end" : "rb-items-center";
         return joinClasses3([options.base, itemsClass]);
@@ -115012,6 +115433,18 @@ var init_media2 = __esm({
     mediaTransforms = [mediaFromUrl];
   }
 });
+
+// ../blocks/src/lib/typeGuards.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isObjectRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+var init_typeGuards2 = __esm({
+  "../blocks/src/lib/typeGuards.ts"() {
+  }
+});
 function getSiteName(context) {
   const viewModel = context.viewModel;
   if (!isRecord5(viewModel)) return null;
@@ -117096,52 +117529,52 @@ var init_media3 = __esm({
       "audio",
       "video"
     ];
-    hotspotSchema2 = z37.object({
-      x: z37.number().min(0).max(1),
-      y: z37.number().min(0).max(1),
-      radius: z37.number().optional()
-    });
-    rotationSchema2 = z37.union([z37.literal(0), z37.literal(90), z37.literal(180), z37.literal(270)]);
-    rectSchema2 = z37.tuple([z37.number(), z37.number(), z37.number(), z37.number()]);
-    aspectCropSchema2 = z37.object({
-      aspect: z37.preprocess((value) => value == null ? void 0 : value, z37.string().optional()),
-      rect: z37.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
-      hotspot: z37.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
-      rotation: z37.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
-    });
-    transformSchema2 = z37.object({
-      aspectCrops: z37.preprocess((value) => {
+    hotspotSchema2 = z38.object({
+      x: z38.number().min(0).max(1),
+      y: z38.number().min(0).max(1),
+      radius: z38.number().optional()
+    });
+    rotationSchema2 = z38.union([z38.literal(0), z38.literal(90), z38.literal(180), z38.literal(270)]);
+    rectSchema2 = z38.tuple([z38.number(), z38.number(), z38.number(), z38.number()]);
+    aspectCropSchema2 = z38.object({
+      aspect: z38.preprocess((value) => value == null ? void 0 : value, z38.string().optional()),
+      rect: z38.preprocess((value) => value == null ? void 0 : value, rectSchema2.optional()),
+      hotspot: z38.preprocess((value) => value == null ? void 0 : value, hotspotSchema2.optional()),
+      rotation: z38.preprocess((value) => value == null ? void 0 : value, rotationSchema2.optional())
+    });
+    transformSchema2 = z38.object({
+      aspectCrops: z38.preprocess((value) => {
         if (!value || typeof value !== "object" || Array.isArray(value)) {
           return void 0;
         }
         return value;
-      }, z37.record(z37.string(), aspectCropSchema2.catch({}))).optional(),
+      }, z38.record(z38.string(), aspectCropSchema2.catch({}))).optional(),
       rect: rectSchema2.optional(),
       hotspot: hotspotSchema2.optional(),
       rotation: rotationSchema2.optional()
     });
-    mediaBaseSchema = z37.object({
-      purpose: z37.string().optional(),
-      placeholder: z37.boolean().default(true).optional(),
-      assetId: z37.string().optional(),
-      identifier: z37.string().optional(),
-      src: z37.string().optional(),
-      alt: z37.string().optional(),
-      filename: z37.string().optional(),
-      mimeType: z37.string().optional(),
-      width: z37.number().optional(),
-      height: z37.number().optional(),
-      storageBucket: z37.string().optional(),
-      storagePath: z37.string().optional(),
+    mediaBaseSchema = z38.object({
+      purpose: z38.string().optional(),
+      placeholder: z38.boolean().default(true).optional(),
+      assetId: z38.string().optional(),
+      identifier: z38.string().optional(),
+      src: z38.string().optional(),
+      alt: z38.string().optional(),
+      filename: z38.string().optional(),
+      mimeType: z38.string().optional(),
+      width: z38.number().optional(),
+      height: z38.number().optional(),
+      storageBucket: z38.string().optional(),
+      storagePath: z38.string().optional(),
       transform: transformSchema2.optional()
     });
-    imageMediaSchema = mediaBaseSchema.extend({ type: z37.literal("image") });
-    videoMediaSchema = mediaBaseSchema.extend({ type: z37.literal("video") });
-    audioMediaSchema = mediaBaseSchema.extend({ type: z37.literal("audio") });
-    documentMediaSchema = mediaBaseSchema.extend({ type: z37.literal("document") });
-    spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z37.literal("spreadsheet") });
-    archiveMediaSchema = mediaBaseSchema.extend({ type: z37.literal("archive") });
-    mediaSchema2 = z37.discriminatedUnion("type", [
+    imageMediaSchema = mediaBaseSchema.extend({ type: z38.literal("image") });
+    videoMediaSchema = mediaBaseSchema.extend({ type: z38.literal("video") });
+    audioMediaSchema = mediaBaseSchema.extend({ type: z38.literal("audio") });
+    documentMediaSchema = mediaBaseSchema.extend({ type: z38.literal("document") });
+    spreadsheetMediaSchema = mediaBaseSchema.extend({ type: z38.literal("spreadsheet") });
+    archiveMediaSchema = mediaBaseSchema.extend({ type: z38.literal("archive") });
+    mediaSchema2 = z38.discriminatedUnion("type", [
       imageMediaSchema,
       videoMediaSchema,
       audioMediaSchema,
@@ -117237,7 +117670,9 @@ var init_schemas = __esm({
     courseTeamMemberSummarySchema = z.object({
       id: z.string(),
       name: z.string(),
-      summary: z.string().nullable()
+      roleLabel: z.string().nullable(),
+      summary: z.string().nullable(),
+      profilePath: z.string().nullable()
     });
     coursePricingOptionSchema = z.object({
       id: z.string(),
@@ -117348,7 +117783,9 @@ var init_schemas2 = __esm({
     publicTeamMemberSummarySchema = z.object({
       id: z.string(),
       name: z.string(),
-      summary: z.string().nullable()
+      roleLabel: z.string().nullable(),
+      summary: z.string().nullable(),
+      profilePath: z.string().nullable()
     });
     publicEventSchema = z.object({
       kind: z.enum(["event", "course_session"]).optional(),
@@ -123555,7 +123992,7 @@ var init_shared8 = __esm({
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
-function assertNever6(value) {
+function assertNever7(value) {
   throw new Error(`Unhandled credit product case: ${String(value)}`);
 }
 function useCasesFromModules(modules) {
@@ -123588,7 +124025,7 @@ function getCreditProductCreditUnit(useCase) {
         perCreditSuffix: "credit"
       };
     default:
-      return assertNever6(useCase);
+      return assertNever7(useCase);
   }
 }
 function deriveCreditProductLabels(products, options = {}) {
@@ -125631,9 +126068,7 @@ var init_newsletter_signup = __esm({
     };
   }
 });
-
-// ../blocks/src/system/blocks/team-members.ts
-var ITEM_NAME7, headingNode, wrapVariant3, teamMemberStackLayout, gridMembersNode, gridVariant, stackMembersNode, stackVariant, teamMembersManifest, teamMembersBlockDefinition;
+var ITEM_NAME7, teamMemberPhotoSchema, teamMemberDataSchema, teamMembersDataSchema, dynamicSourceWhen, manualSourceWhen, headingNode, wrapVariant3, teamMemberStackLayout, manualGridMembersNode, dynamicGridMembersNode, gridVariant, manualStackMembersNode, dynamicStackMembersNode, stackVariant, teamMembersManifest, teamMembersBlockDefinition;
 var init_team_members = __esm({
   "../blocks/src/system/blocks/team-members.ts"() {
     init_fragments2();
@@ -125643,7 +126078,25 @@ var init_team_members = __esm({
     init_fragments();
     init_fragmentCollection();
     init_imageLayout();
+    init_media3();
     ITEM_NAME7 = "member";
+    teamMemberPhotoSchema = mediaSchema2.refine((media2) => media2.type === "image", {
+      message: "Team member photos must be image media"
+    }).nullable();
+    teamMemberDataSchema = z.object({
+      _type: z.literal("teamMember"),
+      id: z.string(),
+      name: z.string(),
+      role: z.string().nullable(),
+      roleLabel: z.string().nullable(),
+      bio: z.string().nullable(),
+      summary: z.string().nullable(),
+      photo: teamMemberPhotoSchema,
+      profilePath: z.string().nullable()
+    });
+    teamMembersDataSchema = z.array(teamMemberDataSchema);
+    dynamicSourceWhen = { equals: "site_staff" };
+    manualSourceWhen = { equals: "site_staff", not: true };
     headingNode = text(
       { as: "h2" },
       bind2("content.heading"),
@@ -125733,7 +126186,15 @@ var init_team_members = __esm({
           ]
         ),
         stack({ gap: "sm", className: "rb-team-member-body rb-flex-1 rb-min-w-0" }, [
-          text({ as: "h3" }, bind2("name")),
+          link(
+            {
+              href: { $bind: { from: "profilePath" } },
+              className: "rb-team-member-name-link"
+            },
+            [text({ as: "h3" }, bind2("name"))],
+            when("profilePath")
+          ),
+          text({ as: "h3" }, when("profilePath", { not: true }), bind2("name")),
           text(
             { as: "p", className: "rb-team-member-role" },
             when("role"),
@@ -125747,12 +126208,18 @@ var init_team_members = __esm({
         ])
       ]
     );
-    gridMembersNode = repeaterFragmentLayout({
+    manualGridMembersNode = when("content.source", manualSourceWhen)(repeaterFragmentLayout({
       collectionPath: "content.members",
       itemName: ITEM_NAME7,
       fragments: { teamMember: teamMemberFragment },
       itemGap: "sm"
-    });
+    }));
+    dynamicGridMembersNode = when("content.source", dynamicSourceWhen)(repeaterFragmentLayout({
+      collectionPath: "data.members",
+      itemName: ITEM_NAME7,
+      fragments: { teamMember: teamMemberFragment },
+      itemGap: "sm"
+    }));
     gridVariant = wrapVariant3(
       el(
         "grid",
@@ -125766,22 +126233,29 @@ var init_team_members = __esm({
           },
           gap: { $bind: { from: "content.gap", fallback: "medium" } }
         },
-        [gridMembersNode]
+        [manualGridMembersNode, dynamicGridMembersNode]
       )
     );
-    stackMembersNode = repeaterFragmentLayout({
+    manualStackMembersNode = when("content.source", manualSourceWhen)(repeaterFragmentLayout({
       collectionPath: "content.members",
       itemName: ITEM_NAME7,
       fragments: { teamMember: teamMemberFragment },
       layoutOverrides: { teamMember: teamMemberStackLayout },
       itemGap: "sm"
-    });
+    }));
+    dynamicStackMembersNode = when("content.source", dynamicSourceWhen)(repeaterFragmentLayout({
+      collectionPath: "data.members",
+      itemName: ITEM_NAME7,
+      fragments: { teamMember: teamMemberFragment },
+      layoutOverrides: { teamMember: teamMemberStackLayout },
+      itemGap: "sm"
+    }));
     stackVariant = wrapVariant3({
       type: "stack",
       props: {
         gap: { $bind: { from: "content.gap", fallback: "medium" } }
       },
-      children: [stackMembersNode]
+      children: [manualStackMembersNode, dynamicStackMembersNode]
     });
     teamMembersManifest = createBlockManifest({
       id: "block.team-members",
@@ -125796,6 +126270,18 @@ var init_team_members = __esm({
           required: false,
           maxLength: 120
         }),
+        parseFieldDefinition({
+          id: "source",
+          type: "select",
+          label: "Team members",
+          description: "Choose whether to use the site-wide team or a hand-picked list.",
+          defaultValue: "manual",
+          options: [
+            { value: "manual", label: "Choose manually" },
+            { value: "site_staff", label: "Use all site team members" }
+          ],
+          ui: { intent: "behavior" }
+        }),
         parseFieldDefinition({
           id: "layoutAlign",
           type: "select",
@@ -125898,18 +126384,24 @@ var init_team_members = __esm({
           ],
           ui: { intent: "display" }
         }),
-        fragmentsToRepeaterField(
-          "members",
-          "Team members",
-          { teamMember: teamMemberFragment },
-          {
-            minItems: 0,
-            maxItems: 50,
-            itemLabel: "Team member",
-            itemLabelSource: "name",
-            description: "Add people to this section."
+        {
+          ...fragmentsToRepeaterField(
+            "members",
+            "Team members",
+            { teamMember: teamMemberFragment },
+            {
+              minItems: 0,
+              maxItems: 50,
+              itemLabel: "Team member",
+              itemLabelSource: "name",
+              description: "Add people to this section."
+            }
+          ),
+          ui: {
+            intent: "content",
+            visibleWhen: { field: "source", equals: "manual" }
           }
-        )
+        }
       ],
       layout: gridVariant,
       variants: {
@@ -125935,7 +126427,20 @@ var init_team_members = __esm({
       styleTokens: { spacing: "lg" }
     });
     teamMembersBlockDefinition = {
-      manifest: teamMembersManifest
+      manifest: teamMembersManifest,
+      dataSchemas: {
+        members: teamMembersDataSchema
+      },
+      dataLoaders: {
+        members: {
+          endpoint: "listPublicTeamMembers",
+          params: {
+            siteId: { $bind: { from: "$root.siteId" } },
+            stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+          },
+          mode: "server"
+        }
+      }
     };
   }
 });
@@ -128813,7 +129318,7 @@ function okWith(data) {
 function err2(error) {
   return { ok: false, error };
 }
-function assertNever7(value, message2) {
+function assertNever8(value, message2) {
   throw new Error(`Unexpected value: ${String(value)}`);
 }
 var init_dist88 = __esm({
@@ -128958,7 +129463,7 @@ function deriveBookingFormViewState(input) {
         resourceName: input.verificationState.resourceName
       };
     default:
-      return assertNever7(input.verificationState);
+      return assertNever8(input.verificationState);
   }
 }
 function resolveBookingSiteId(siteId, form2) {
@@ -129041,7 +129546,7 @@ function getBookingServicePaymentSelectionMode(service) {
       case "flexible_balance":
         return "implicit_flexible_balance";
       default:
-        return assertNever7(onlyKind);
+        return assertNever8(onlyKind);
     }
   }
   if (allowedKinds.length === 2 && allowedKinds.includes("upfront") && (allowedKinds.includes("deferred_manual") || allowedKinds.includes("instalment_plan") || allowedKinds.includes("flexible_balance"))) {
@@ -129243,7 +129748,7 @@ function formatBookingSubmissionPreparationError(error) {
     case "service-missing-duration":
       return `Service "${error.serviceTitle}" is missing duration. Please update the service in the dashboard to include a duration (e.g., 30 minutes).`;
     default:
-      return assertNever7(error);
+      return assertNever8(error);
   }
 }
 function getBookingSuccessMessage(successMessage) {
@@ -129658,6 +130163,12 @@ var init_CoursePricingDisplay = __esm({
     init_shared6();
   }
 });
+function TeamMemberName({
+  name,
+  profilePath
+}) {
+  return profilePath ? /* @__PURE__ */ jsx("a", { href: profilePath, className: "rb-hover-opacity-80", children: /* @__PURE__ */ jsx("strong", { children: name }) }) : /* @__PURE__ */ jsx("strong", { children: name });
+}
 function EventDetailsView({
   selection,
   showVenue,
@@ -129721,7 +130232,13 @@ function EventDetailsView({
         teamMembers.length > 0 ? /* @__PURE__ */ jsxs("div", { className: "rb-mt-6", children: [
           /* @__PURE__ */ jsx("div", { className: "rb-label rb-mb-2", children: "Team members" }),
           /* @__PURE__ */ jsx("div", { className: "rb-flex rb-flex-col rb-gap-3", children: teamMembers.map((teamMember) => /* @__PURE__ */ jsxs("div", { children: [
-            /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("strong", { children: teamMember.name }) }),
+            /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx(
+              TeamMemberName,
+              {
+                name: teamMember.name,
+                profilePath: teamMember.profilePath
+              }
+            ) }),
             teamMember.summary ? /* @__PURE__ */ jsx("p", { className: "rb-caption status-muted", children: teamMember.summary }) : null
           ] }, teamMember.id)) })
         ] }) : null,
@@ -130094,6 +130611,12 @@ var init_runs = __esm({
     init_src3();
   }
 });
+function TeamMemberName2({
+  name,
+  profilePath
+}) {
+  return profilePath ? /* @__PURE__ */ jsx("a", { href: profilePath, className: "rb-hover-opacity-80", children: /* @__PURE__ */ jsx("strong", { children: name }) }) : /* @__PURE__ */ jsx("strong", { children: name });
+}
 function parseLimit2(value, fallback2) {
   if (value === "all") return "all";
   const n3 = typeof value === "string" ? Number.parseInt(value, 10) : typeof value === "number" ? value : NaN;
@@ -130151,7 +130674,13 @@ function CourseDetailsView(props2) {
         teamMembers.length > 0 && /* @__PURE__ */ jsxs("div", { children: [
           /* @__PURE__ */ jsx("div", { className: "rb-label rb-mb-2", children: "Team members" }),
           /* @__PURE__ */ jsx("div", { className: "rb-flex rb-flex-col rb-gap-3", children: teamMembers.map((teamMember) => /* @__PURE__ */ jsxs("div", { children: [
-            /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx("strong", { children: teamMember.name }) }),
+            /* @__PURE__ */ jsx("p", { children: /* @__PURE__ */ jsx(
+              TeamMemberName2,
+              {
+                name: teamMember.name,
+                profilePath: teamMember.profilePath
+              }
+            ) }),
             teamMember.summary && /* @__PURE__ */ jsx("p", { className: "rb-caption status-muted", children: teamMember.summary })
           ] }, teamMember.id)) })
         ] })
@@ -132351,7 +132880,7 @@ function readFromSource(source, segments) {
     return void 0;
   }, source);
 }
-function isPlainObject4(value) {
+function isPlainObject5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseRouteEntry(routeId, value) {
@@ -132361,35 +132890,35 @@ function parseRouteEntry(routeId, value) {
   if (typeof value === "string") {
     return [routeId, value];
   }
-  if (isPlainObject4(value)) {
+  if (isPlainObject5(value)) {
     return [routeId, value];
   }
   return null;
 }
 function extractRouteMapFromViewModel(viewModel) {
-  if (!isPlainObject4(viewModel)) return void 0;
+  if (!isPlainObject5(viewModel)) return void 0;
   const root = viewModel.$root;
-  if (!isPlainObject4(root)) return void 0;
+  if (!isPlainObject5(root)) return void 0;
   const routes = root.routes;
-  if (!isPlainObject4(routes)) return void 0;
+  if (!isPlainObject5(routes)) return void 0;
   const entries = Object.entries(routes).map(([routeId, value]) => parseRouteEntry(routeId, value)).filter((entry) => entry !== null);
   if (entries.length === 0) return void 0;
   return Object.fromEntries(entries);
 }
 function extractPagesByIdentifierFromViewModel(viewModel) {
-  if (!isPlainObject4(viewModel)) return void 0;
+  if (!isPlainObject5(viewModel)) return void 0;
   const root = viewModel.$root;
-  if (!isPlainObject4(root)) return void 0;
+  if (!isPlainObject5(root)) return void 0;
   const pagesByIdentifier = root.pagesByIdentifier;
-  if (!isPlainObject4(pagesByIdentifier)) return void 0;
+  if (!isPlainObject5(pagesByIdentifier)) return void 0;
   return pagesByIdentifier;
 }
 function extractEntriesByIdentifierFromViewModel(viewModel) {
-  if (!isPlainObject4(viewModel)) return void 0;
+  if (!isPlainObject5(viewModel)) return void 0;
   const root = viewModel.$root;
-  if (!isPlainObject4(root)) return void 0;
+  if (!isPlainObject5(root)) return void 0;
   const entriesByIdentifier = root.entriesByIdentifier;
-  if (!isPlainObject4(entriesByIdentifier)) return void 0;
+  if (!isPlainObject5(entriesByIdentifier)) return void 0;
   return entriesByIdentifier;
 }
 function parseBinding(raw, origin) {
@@ -132405,7 +132934,7 @@ function applyTransformsAndFallback(value, binding, context) {
   const routeMap = context.routes ?? extractRouteMapFromViewModel(context.viewModel);
   const pagesByIdentifier = context.pagesByIdentifier ?? extractPagesByIdentifierFromViewModel(context.viewModel);
   const entriesByIdentifier = context.entriesByIdentifier ?? extractEntriesByIdentifierFromViewModel(context.viewModel);
-  const root = isPlainObject4(context.viewModel.$root) ? context.viewModel.$root : null;
+  const root = isPlainObject5(context.viewModel.$root) ? context.viewModel.$root : null;
   const stage = root?.previewStage === "preview" ? "preview" : "published";
   const transformed = runTransforms(
     value,
@@ -132442,21 +132971,21 @@ function resolveTransformData(context, bindingPath) {
   const [first2] = segments;
   if (typeof first2 === "string" && first2 !== "$root") {
     const namedScope = context.scopes.find((entry) => entry.name === first2);
-    if (namedScope && isPlainObject4(namedScope.value)) {
+    if (namedScope && isPlainObject5(namedScope.value)) {
       return namedScope.value;
     }
   }
   for (let i2 = context.scopes.length - 1; i2 >= 0; i2 -= 1) {
     const scope = context.scopes[i2];
-    if (scope && isPlainObject4(scope.value)) {
+    if (scope && isPlainObject5(scope.value)) {
       return scope.value;
     }
   }
   const content = context.viewModel.content;
-  if (isPlainObject4(content)) {
+  if (isPlainObject5(content)) {
     return content;
   }
-  if (isPlainObject4(context.viewModel)) {
+  if (isPlainObject5(context.viewModel)) {
     return context.viewModel;
   }
   return void 0;
@@ -132591,7 +133120,7 @@ function getNestedBinding(bindings, path) {
   const segments = path.split(".");
   let current = bindings;
   for (const segment of segments) {
-    if (!isPlainObject4(current)) return void 0;
+    if (!isPlainObject5(current)) return void 0;
     current = current[segment];
   }
   return current;
@@ -132605,7 +133134,7 @@ function resolveBindingToEditorPath(fieldName, bindings, editableRouteMetadataFi
   };
   const binding = bindings[fieldName] ?? getNestedBinding(bindings, fieldName);
   if (!binding) return null;
-  if (isPlainObject4(binding) && "source" in binding) {
+  if (isPlainObject5(binding) && "source" in binding) {
     const source = binding.source;
     if (source === "field" && "path" in binding) {
       const path = binding.path;
@@ -132624,7 +133153,7 @@ function resolveBindingToEditorPath(fieldName, bindings, editableRouteMetadataFi
         if (typeof option === "string") {
           return `content.${option}`;
         }
-        if (isPlainObject4(option) && "source" in option) {
+        if (isPlainObject5(option) && "source" in option) {
           const optSource = option.source;
           if (optSource === "field" && "path" in option) {
             const path = option.path;
@@ -132669,7 +133198,7 @@ function injectEditorPath(props2, node, parsedBinding, context) {
     }
   }
   const root = context.viewModel?.$root;
-  const isEntryTemplatePage = isPlainObject4(root) && root.contentEntry != null;
+  const isEntryTemplatePage = isPlainObject5(root) && root.contentEntry != null;
   if (isEntryTemplatePage && context.pathBase) return props2;
   const prefix = context.pathBase ?? "";
   const injectedPath = `${prefix}${fieldPath}`;
@@ -132698,7 +133227,7 @@ function injectMediaSlotPath(props2, node, parsedBinding, context) {
     if (entryPath) return props2;
   }
   const root = context.viewModel?.$root;
-  const isEntryTemplatePage = isPlainObject4(root) && root.contentEntry != null;
+  const isEntryTemplatePage = isPlainObject5(root) && root.contentEntry != null;
   if (isEntryTemplatePage && context.pathBase) return props2;
   return {
     ...props2,
@@ -132802,7 +133331,7 @@ function getNodeProps(node) {
     if (key.startsWith("$")) continue;
     legacy[key] = value;
   }
-  const props2 = isPlainObject4(node.props) ? node.props : {};
+  const props2 = isPlainObject5(node.props) ? node.props : {};
   return { ...legacy, ...props2 };
 }
 function resolveTree(node, options) {
@@ -132869,14 +133398,14 @@ var init_runtime2 = __esm({
 });
 
 // ../theme-core/src/blockOverrides.ts
-function isPlainObject5(value) {
+function isPlainObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function cloneValue(value) {
   if (Array.isArray(value)) {
     return value.map((item) => cloneValue(item));
   }
-  if (isPlainObject5(value)) {
+  if (isPlainObject6(value)) {
     const cloned = {};
     for (const [key, child] of Object.entries(value)) {
       cloned[key] = cloneValue(child);
@@ -132892,7 +133421,7 @@ function mergeDeep2(defaultValue2, overrideValue) {
   if (overrideValue === null) {
     return null;
   }
-  if (isPlainObject5(defaultValue2) && isPlainObject5(overrideValue)) {
+  if (isPlainObject6(defaultValue2) && isPlainObject6(overrideValue)) {
     const merged = {};
     const keys2 = /* @__PURE__ */ new Set([...Object.keys(defaultValue2), ...Object.keys(overrideValue)]);
     for (const key of keys2) {
@@ -133084,12 +133613,6 @@ var init_ai = __esm({
   }
 });
 
-// ../blocks/src/system/types/link.ts
-var init_link2 = __esm({
-  "../blocks/src/system/types/link.ts"() {
-  }
-});
-
 // ../blocks/src/system/index.ts
 var init_system = __esm({
   "../blocks/src/system/index.ts"() {
@@ -137187,7 +137710,7 @@ function resolveBlockData({
 }
 function getRenderableContent(block) {
   const source = block.draftContent ?? block.content ?? {};
-  if (!isObjectRecord(source)) {
+  if (!isObjectRecord2(source)) {
     return {};
   }
   return source;
@@ -137206,8 +137729,8 @@ function summarizeValue(value) {
       for (const k of keys2.slice(0, 8)) {
         const v2 = rec[k];
         if (k === "body" || k === "content") {
-          const isDocWrapper = !!(v2 && typeof v2 === "object" && isObjectRecord(v2) && "doc" in v2);
-          const isDoc = !!(v2 && typeof v2 === "object" && isObjectRecord(v2) && v2.type === "doc");
+          const isDocWrapper = !!(v2 && typeof v2 === "object" && isObjectRecord2(v2) && "doc" in v2);
+          const isDoc = !!(v2 && typeof v2 === "object" && isObjectRecord2(v2) && v2.type === "doc");
           preview[k] = isDocWrapper ? "{doc}" : isDoc ? "{type:doc}" : summarizeValue(v2);
         } else {
           preview[k] = summarizeValue(v2);
@@ -139086,25 +139609,25 @@ var init_Button2 = __esm({
 var BlockKind, blockSchema, pagePath;
 var init_schema5 = __esm({
   "../blocks/src/structure/schema.ts"() {
-    BlockKind = z37.string();
-    blockSchema = z37.object({
-      id: z37.string().nullable(),
+    BlockKind = z38.string();
+    blockSchema = z38.object({
+      id: z38.string().nullable(),
       // optional ID for reference in toggle ops
       kind: BlockKind,
-      purpose: z37.string().min(1),
+      purpose: z38.string().min(1),
       // Optional content fields used by PageRenderer / block runtime.
-      content: z37.record(z37.string(), z37.unknown()).optional(),
+      content: z38.record(z38.string(), z38.unknown()).optional(),
       // Nullable because some persisted sources store "no draft" as null.
-      draftContent: z37.record(z37.string(), z37.unknown()).nullable().optional(),
+      draftContent: z38.record(z38.string(), z38.unknown()).nullable().optional(),
       // Optional template bindings for reverse field mapping (entry editing)
-      bindings: z37.record(z37.string(), z37.unknown()).optional()
+      bindings: z38.record(z38.string(), z38.unknown()).optional()
     }).passthrough();
-    pagePath = z37.string().regex(/^\/[\S]*$/, 'path must start with "/" and contain no spaces');
-    z37.object({
-      name: z37.string().min(1),
+    pagePath = z38.string().regex(/^\/[\S]*$/, 'path must start with "/" and contain no spaces');
+    z38.object({
+      name: z38.string().min(1),
       path: pagePath,
-      purpose: z37.string().min(1),
-      blocks: z37.array(blockSchema).min(1)
+      purpose: z38.string().min(1),
+      blocks: z38.array(blockSchema).min(1)
     });
   }
 });
@@ -148433,6 +148956,7 @@ var init_loaderEndpoints = __esm({
       "listPublicEvents",
       "getPublicEventDetails",
       "listPublicCourses",
+      "listPublicTeamMembers",
       "listPublicProducts",
       "listPublicPasses",
       "listPublicMemberships",
@@ -148495,6 +149019,7 @@ var init_src6 = __esm({
     init_buildThemeRuntimeFromBridge();
     init_blocks4();
     init_system();
+    init_link2();
     init_validation();
     init_primitives();
     init_media4();
@@ -148545,10 +149070,10 @@ function deriveBlockDraftSaveability(input) {
     issues
   };
 }
-function withNormalizedManifestMessage(issue) {
+function withNormalizedManifestMessage(issue2) {
   return {
-    ...issue,
-    message: normalizeManifestIssueMessage(issue)
+    ...issue2,
+    message: normalizeManifestIssueMessage(issue2)
   };
 }
 function validateBlockManifestIssues(manifest, values, mode) {
@@ -148560,31 +149085,31 @@ function validateBlockManifestIssues(manifest, values, mode) {
   return result.error.issues.map(withNormalizedManifestMessage);
 }
 function validateBlockManifest(manifest, values, mode) {
-  return validateBlockManifestIssues(manifest, values, mode).map((issue) => {
-    const path = normalizeIssuePath(issue.path);
+  return validateBlockManifestIssues(manifest, values, mode).map((issue2) => {
+    const path = normalizeIssuePath(issue2.path);
     return {
-      code: issue.code,
+      code: issue2.code,
       path,
       fieldPath: normalizePathString(path),
-      message: issue.message
+      message: issue2.message
     };
   });
 }
-function normalizeManifestIssueMessage(issue) {
-  switch (issue.code) {
+function normalizeManifestIssueMessage(issue2) {
+  switch (issue2.code) {
     case "invalid_type":
-      return issue.message;
+      return issue2.message;
     case "too_big":
-      return issue.origin === "string" ? `Use ${issue.maximum} characters or fewer` : issue.message;
+      return issue2.origin === "string" ? `Use ${issue2.maximum} characters or fewer` : issue2.message;
     case "too_small":
-      if (issue.origin !== "string") return issue.message;
-      return issue.minimum === 1 ? "This field is required" : `Use at least ${issue.minimum} characters`;
+      if (issue2.origin !== "string") return issue2.message;
+      return issue2.minimum === 1 ? "This field is required" : `Use at least ${issue2.minimum} characters`;
     case "invalid_format":
-      if (issue.format === "email") return "Enter a valid email address";
-      if (issue.format === "url") return "Enter a valid web address";
+      if (issue2.format === "email") return "Enter a valid email address";
+      if (issue2.format === "url") return "Enter a valid web address";
       return "Check the format and try again";
     default:
-      return issue.message;
+      return issue2.message;
   }
 }
 function getManifestValidation(manifest, mode) {
@@ -148739,16 +149264,16 @@ function validateAllBlocks(uiStore) {
     }
     const issues = validateBlockManifest(definition.manifest, content, "strict");
     if (issues.length > 0) {
-      for (const issue of issues) {
+      for (const issue2 of issues) {
         errors.push({
           blockId: snapshot2.id,
           blockKind: snapshot2.meta.kind,
-          fieldPath: issue.fieldPath,
+          fieldPath: issue2.fieldPath,
           fieldLabel: getFieldLabelFromManifest(
             definition.manifest,
-            issue.path
+            issue2.path
           ),
-          message: issue.message
+          message: issue2.message
         });
       }
     }
@@ -149512,7 +150037,7 @@ var init_extractBlockData = __esm({
 });
 
 // ../content-editor/src/utils/assertNever.ts
-function assertNever8(value, message2) {
+function assertNever9(value, message2) {
   throw new Error(`Unexpected value: ${String(value)}`);
 }
 var init_assertNever2 = __esm({
@@ -150110,7 +150635,7 @@ function applyEditorCommand(snapshot2, command2) {
       return nextSnapshot;
     }
     default:
-      return assertNever8(command2);
+      return assertNever9(command2);
   }
 }
 function applyUserOperation(snapshot2, operation) {
@@ -150182,7 +150707,7 @@ function applySystemOperation(snapshot2, operation) {
     case "replace-block-list":
       return replaceEditorBlockList(snapshot2, operation.next);
     default:
-      return assertNever8(operation);
+      return assertNever9(operation);
   }
 }
 function hydrateMetadataSnapshot(snapshot2, baseline, current, published) {
@@ -151952,7 +152477,7 @@ function toDrainFailure(effect, error) {
     case "persist-remove":
       return { kind: effect.type, message: message2 };
     default:
-      return assertNever8(effect);
+      return assertNever9(effect);
   }
 }
 async function drainEditorEffect(effect, context) {
@@ -151964,7 +152489,7 @@ async function drainEditorEffect(effect, context) {
     case "persist-remove":
       return drainPersistRemoveEffect(effect, context);
     default:
-      return assertNever8(effect);
+      return assertNever9(effect);
   }
 }
 async function drainEditorEffects(effects, context) {
@@ -153024,40 +153549,151 @@ var init_TextField = __esm({
     init_FieldFrame();
   }
 });
-function withTextFieldSharedRules(schema, field) {
-  const maxLengthMessage = typeof field.maxLength === "number" ? `${field.label} must be ${field.maxLength} characters or less` : void 0;
-  let withRules = schema;
-  if (typeof field.maxLength === "number") {
-    withRules = withRules.max(field.maxLength, { message: maxLengthMessage });
+
+// ../block-form/src/widgets/utils/readNumericUiConfig.ts
+function readNumericInputUiConfig(ui) {
+  if (!ui || typeof ui !== "object") return {};
+  const rec = ui;
+  return {
+    min: typeof rec.min === "number" ? rec.min : void 0,
+    max: typeof rec.max === "number" ? rec.max : void 0,
+    step: typeof rec.step === "number" ? rec.step : void 0
+  };
+}
+function readNumberFieldUiConfig(ui) {
+  return readNumericInputUiConfig(ui);
+}
+function readSliderFieldUiConfig(ui) {
+  const base2 = readNumericInputUiConfig(ui);
+  if (!ui || typeof ui !== "object") return base2;
+  const rec = ui;
+  return {
+    ...base2,
+    showValue: typeof rec.showValue === "boolean" ? rec.showValue : void 0
+  };
+}
+var init_readNumericUiConfig = __esm({
+  "../block-form/src/widgets/utils/readNumericUiConfig.ts"() {
   }
-  if (field.required) {
-    return withRules.min(1, "This field is required");
+});
+
+// ../block-form/src/manifest/canonicalValidation.ts
+function buildCanonicalFieldSchema(field) {
+  const manifestField = normalizeFieldForCanonicalValidation(field);
+  return fieldPlanToZod(deriveFieldValidationPlan(manifestField), {
+    allowNull: !Boolean(field.required)
+  });
+}
+function normalizeFieldForCanonicalValidation(field) {
+  return parseFieldDefinition(toManifestFieldInput(field));
+}
+function toManifestFieldInput(field) {
+  switch (field.type) {
+    case "number":
+      return numberFieldToManifestInput(field);
+    case "group":
+      return groupFieldToManifestInput(field);
+    case "modal":
+      return modalFieldToManifestInput(field);
+    case "repeater":
+      return repeaterFieldToManifestInput(field);
+    case "tabGroup":
+      return {
+        ...field,
+        tabs: field.tabs.map((tab) => ({
+          ...tab,
+          fields: tab.fields.map(toManifestFieldInput)
+        }))
+      };
+    case "button":
+      throw new Error("Button fields do not have canonical content validation");
+    case "text":
+    case "richText":
+    case "media":
+    case "boolean":
+    case "date":
+    case "time":
+    case "datetime":
+    case "slug":
+    case "url":
+    case "link":
+    case "select":
+    case "reference":
+    case "presetOrCustom":
+    case "contentTypeSelect":
+    case "entryPicker":
+      return field;
   }
-  return withRules.optional().nullable().or(z.literal(""));
+  return assertNever10(field);
 }
-function buildTextFieldSchema(field) {
-  const inputType = field.ui?.inputType;
-  if (inputType === "email") {
-    return withTextFieldSharedRules(z.string().email("Enter a valid email"), field);
-  }
-  if (inputType === "tel") {
-    return withTextFieldSharedRules(
-      z.string().regex(/^[+()0-9\s\-]{3,}$/, "Enter a valid phone number"),
-      field
-    );
+function numberFieldToManifestInput(field) {
+  const ui = readNumberFieldUiConfig(field.ui);
+  return {
+    ...field,
+    min: field.min ?? ui.min,
+    max: field.max ?? ui.max,
+    step: field.step ?? ui.step
+  };
+}
+function groupFieldToManifestInput(field) {
+  return {
+    ...field,
+    schema: {
+      ...field.schema,
+      fields: (field.schema?.fields ?? field.fields).map(toManifestFieldInput)
+    }
+  };
+}
+function modalFieldToManifestInput(field) {
+  return {
+    ...field,
+    schema: {
+      ...field.schema,
+      fields: field.schema.fields.map(toManifestFieldInput)
+    }
+  };
+}
+function repeaterFieldToManifestInput(field) {
+  if (field.polymorphic) {
+    return {
+      ...field,
+      itemTypes: Object.fromEntries(
+        Object.entries(field.itemTypes).map(([typeId, itemType]) => [
+          typeId,
+          {
+            ...itemType,
+            fields: itemType.fields.map(toManifestFieldInput)
+          }
+        ])
+      )
+    };
   }
-  let s2 = z.string();
-  if (field.ui?.pattern) {
-    try {
-      const re2 = new RegExp(field.ui.pattern);
-      s2 = s2.regex(re2, { message: `${field.label} is not in the right format` });
-    } catch {
+  return {
+    ...field,
+    schema: {
+      ...field.schema,
+      fields: (field.schema?.fields ?? field.fields).map(toManifestFieldInput)
     }
+  };
+}
+function assertNever10(value) {
+  throw new Error(`Unhandled field config variant: ${JSON.stringify(value)}`);
+}
+var init_canonicalValidation = __esm({
+  "../block-form/src/manifest/canonicalValidation.ts"() {
+    init_fieldValidation();
+    init_schema3();
+    init_readNumericUiConfig();
   }
-  return withTextFieldSharedRules(s2, field);
+});
+
+// ../block-form/src/widgets/TextField/textFieldSchema.ts
+function buildTextFieldSchema(field) {
+  return buildCanonicalFieldSchema(field);
 }
 var init_textFieldSchema = __esm({
   "../block-form/src/widgets/TextField/textFieldSchema.ts"() {
+    init_canonicalValidation();
   }
 });
 
@@ -153082,33 +153718,6 @@ var init_TextField2 = __esm({
     init_TextField();
   }
 });
-
-// ../block-form/src/widgets/utils/readNumericUiConfig.ts
-function readNumericInputUiConfig(ui) {
-  if (!ui || typeof ui !== "object") return {};
-  const rec = ui;
-  return {
-    min: typeof rec.min === "number" ? rec.min : void 0,
-    max: typeof rec.max === "number" ? rec.max : void 0,
-    step: typeof rec.step === "number" ? rec.step : void 0
-  };
-}
-function readNumberFieldUiConfig(ui) {
-  return readNumericInputUiConfig(ui);
-}
-function readSliderFieldUiConfig(ui) {
-  const base2 = readNumericInputUiConfig(ui);
-  if (!ui || typeof ui !== "object") return base2;
-  const rec = ui;
-  return {
-    ...base2,
-    showValue: typeof rec.showValue === "boolean" ? rec.showValue : void 0
-  };
-}
-var init_readNumericUiConfig = __esm({
-  "../block-form/src/widgets/utils/readNumericUiConfig.ts"() {
-  }
-});
 function NumberField({ path, backend, config }) {
   const { value, error, setValue } = useField(path, backend);
   const ui = readNumberFieldUiConfig(config.ui);
@@ -153148,44 +153757,14 @@ var init_NumberField = __esm({
     init_readNumericUiConfig();
   }
 });
+
+// ../block-form/src/widgets/NumberField/numberFieldSchema.ts
 function buildNumberFieldSchema(field) {
-  const requiredMessage = "This field is required";
-  const numberMessage = `${field.label} needs a number`;
-  let numberSchema = z.coerce.number({
-    error: (issue) => issue.input === void 0 ? requiredMessage : numberMessage
-  });
-  if (typeof field.ui?.min === "number") {
-    numberSchema = numberSchema.min(field.ui.min, {
-      message: `${field.label} must be ${field.ui.min} or more`
-    });
-  }
-  if (typeof field.ui?.max === "number") {
-    numberSchema = numberSchema.max(field.ui.max, {
-      message: `${field.label} must be ${field.ui.max} or less`
-    });
-  }
-  const emptyToUndefined = (value) => value === "" || value === null ? void 0 : value;
-  if (!field.required) {
-    return z.preprocess(emptyToUndefined, numberSchema.optional().nullable());
-  }
-  return z.preprocess(
-    emptyToUndefined,
-    z.unknown().superRefine((value, ctx) => {
-      if (value === void 0) {
-        ctx.addIssue({ code: "custom", message: requiredMessage });
-        return;
-      }
-      const parsed = numberSchema.safeParse(value);
-      if (!parsed.success) {
-        for (const issue of parsed.error.issues) {
-          ctx.addIssue({ code: "custom", message: issue.message });
-        }
-      }
-    }).transform((value) => Number(value))
-  );
+  return buildCanonicalFieldSchema(field);
 }
 var init_numberFieldSchema = __esm({
   "../block-form/src/widgets/NumberField/numberFieldSchema.ts"() {
+    init_canonicalValidation();
   }
 });
 
@@ -153322,29 +153901,14 @@ var init_SelectField = __esm({
     init_selectValueMapping();
   }
 });
+
+// ../block-form/src/widgets/SelectField/selectFieldSchema.ts
 function buildSelectFieldSchema(field) {
-  const validValues = field.options?.map((opt) => opt.value) ?? [];
-  const requiredMessage = "This field is required";
-  const invalidOptionMessage = `Choose one of the available options for ${field.label}`;
-  if (validValues.length === 0) {
-    if (field.multiple) {
-      const arr = z.array(z.string());
-      return field.required ? arr.min(1, { message: requiredMessage }) : arr.nullable();
-    }
-    const single = z.string();
-    return field.required ? single.min(1, { message: requiredMessage }) : single.nullable();
-  }
-  const base2 = z.enum(validValues, {
-    error: invalidOptionMessage
-  });
-  if (field.multiple) {
-    const arr = z.array(base2);
-    return field.required ? arr.min(1, { message: requiredMessage }) : arr.nullable();
-  }
-  return field.required ? base2 : base2.nullable();
+  return buildCanonicalFieldSchema(field);
 }
 var init_selectFieldSchema = __esm({
   "../block-form/src/widgets/SelectField/selectFieldSchema.ts"() {
+    init_canonicalValidation();
   }
 });
 
@@ -154446,7 +155010,7 @@ function createStoreBackend(options) {
       return issues;
     }
     return issues.filter(
-      (issue) => blockValidation.isPathEdited(currentBlockId, issue.path.join("."))
+      (issue2) => blockValidation.isPathEdited(currentBlockId, issue2.path.join("."))
     );
   };
   return {
@@ -154488,7 +155052,7 @@ function createStoreBackend(options) {
       let fieldError;
       if (validateFn) {
         const issues = getVisibleValidationIssues();
-        const fieldIssue = issues.find((issue) => issue.path.join(".") === path);
+        const fieldIssue = issues.find((issue2) => issue2.path.join(".") === path);
         if (fieldIssue) {
           fieldError = { message: fieldIssue.message };
         }
@@ -154513,9 +155077,9 @@ function createStoreBackend(options) {
     getErrors: () => {
       const issues = getVisibleValidationIssues();
       const errors = {};
-      issues.forEach((issue) => {
-        const path = issue.path.join(".");
-        errors[path] = { message: issue.message };
+      issues.forEach((issue2) => {
+        const path = issue2.path.join(".");
+        errors[path] = { message: issue2.message };
       });
       return errors;
     },
@@ -154599,9 +155163,9 @@ function createStoreBackend(options) {
       const issues = getValidationIssues();
       const visibleIssues = getVisibleValidationIssues();
       const errors = {};
-      visibleIssues.forEach((issue) => {
-        const path = issue.path.join(".");
-        errors[path] = { message: issue.message };
+      visibleIssues.forEach((issue2) => {
+        const path = issue2.path.join(".");
+        errors[path] = { message: issue2.message };
       });
       return {
         isDirty: isSnapshotDirty(snapshot2),
@@ -154641,12 +155205,6 @@ var init_types22 = __esm({
   }
 });
 
-// ../block-form/src/backend/validation.ts
-var init_validation3 = __esm({
-  "../block-form/src/backend/validation.ts"() {
-  }
-});
-
 // ../block-form/src/backend/adapter.ts
 var init_adapter = __esm({
   "../block-form/src/backend/adapter.ts"() {
@@ -154731,7 +155289,6 @@ var init_backend = __esm({
   "../block-form/src/backend/index.ts"() {
     init_types22();
     init_hooks();
-    init_validation3();
     init_adapter();
     init_useRepeaterBackend();
   }
@@ -156108,7 +156665,7 @@ function ze() {
     /* @__PURE__ */ Te(P)
   );
 }
-function z70(e3) {
+function z69(e3) {
   if (L2) {
     if (/* @__PURE__ */ Te(P) !== null)
       throw Tt(), Je;
@@ -158137,12 +158694,12 @@ function ha(e3, t3) {
   var mt = we(Dr, 2);
   let Pr;
   var We = X3(mt);
-  en(We), We.__change = ui, z70(mt);
+  en(We), We.__change = ui, z69(mt);
   var Ut = we(mt, 2), wi = X3(Ut);
   {
     var pi = (n3) => {
       var u3 = na(), _2 = Gr(u3), y2 = X3(_2);
-      Ge(y2, () => c3(re2).verified), z70(_2);
+      Ge(y2, () => c3(re2).verified), z69(_2);
       var T2 = we(_2, 2);
       en(T2), Pe(() => {
         se(T2, "name", V2()), jo(T2, c3(Le));
@@ -158151,10 +158708,10 @@ function ha(e3, t3) {
       {
         var _2 = (T2) => {
           var E = ia(), p2 = X3(E);
-          Ge(p2, () => c3(re2).verifying), z70(E), ne(T2, E);
+          Ge(p2, () => c3(re2).verifying), z69(E), ne(T2, E);
         }, y2 = (T2) => {
           var E = oa(), p2 = X3(E);
-          Ge(p2, () => c3(re2).label), z70(E), Pe(() => se(E, "for", c3(cr))), ne(T2, E);
+          Ge(p2, () => c3(re2).label), z69(E), Pe(() => se(E, "for", c3(cr))), ne(T2, E);
         };
         $e(
           n3,
@@ -158169,18 +158726,18 @@ function ha(e3, t3) {
       c3(C2) === b2.VERIFIED ? n3(pi) : n3(bi, false);
     });
   }
-  z70(Ut);
+  z69(Ut);
   var yi = we(Ut, 2);
   {
     var Ei = (n3) => {
       var u3 = aa(), _2 = X3(u3);
-      se(_2, "href", sr), z70(u3), Pe(() => se(_2, "aria-label", c3(re2).ariaLinkLabel)), ne(n3, u3);
+      se(_2, "href", sr), z69(u3), Pe(() => se(_2, "aria-label", c3(re2).ariaLinkLabel)), ne(n3, u3);
     };
     $e(yi, (n3) => {
       (N() !== true || c3(Dt)) && n3(Ei);
     });
   }
-  z70(Mt);
+  z69(Mt);
   var Or = we(Mt, 2);
   {
     var xi = (n3) => {
@@ -158188,16 +158745,16 @@ function ha(e3, t3) {
       {
         var y2 = (E) => {
           var p2 = la(), x2 = X3(p2);
-          Ge(x2, () => c3(re2).expired), z70(p2), Pe(() => se(p2, "title", c3(He))), ne(E, p2);
+          Ge(x2, () => c3(re2).expired), z69(p2), Pe(() => se(p2, "title", c3(He))), ne(E, p2);
         }, T2 = (E) => {
           var p2 = sa(), x2 = X3(p2);
-          Ge(x2, () => c3(re2).error), z70(p2), Pe(() => se(p2, "title", c3(He))), ne(E, p2);
+          Ge(x2, () => c3(re2).error), z69(p2), Pe(() => se(p2, "title", c3(He))), ne(E, p2);
         };
         $e(_2, (E) => {
           c3(C2) === b2.EXPIRED ? E(y2) : E(T2, false);
         });
       }
-      z70(u3), ne(n3, u3);
+      z69(u3), ne(n3, u3);
     };
     $e(Or, (n3) => {
       (c3(He) || c3(C2) === b2.EXPIRED) && n3(xi);
@@ -158207,7 +158764,7 @@ function ha(e3, t3) {
   {
     var $i = (n3) => {
       var u3 = ua(), _2 = X3(u3), y2 = X3(_2);
-      Ge(y2, () => c3(re2).footer), z70(_2), z70(u3), ne(n3, u3);
+      Ge(y2, () => c3(re2).footer), z69(_2), z69(u3), ne(n3, u3);
     };
     $e(Fr, (n3) => {
       c3(re2).footer && (k() !== true || c3(Dt)) && n3($i);
@@ -158223,7 +158780,7 @@ function ha(e3, t3) {
       v2() && n3(Ci);
     });
   }
-  return z70(ot), nn(ot, (n3) => D2(B, n3), () => c3(B)), Pe(
+  return z69(ot), nn(ot, (n3) => D2(B, n3), () => c3(B)), Pe(
     (n3) => {
       se(ot, "data-state", c3(C2)), se(ot, "data-floating", v2()), Pr = Fo(mt, 1, "altcha-checkbox", null, Pr, n3), se(We, "id", c3(cr)), We.required = r4() !== "onsubmit" && (!v2() || r4() !== "off");
     },
@@ -158970,7 +159527,7 @@ function multiStepReducer(state, action) {
     case "reset":
       return createInitialMultiStepState(action.initialData);
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 function getVisibleSteps(steps2, data) {
@@ -159829,7 +160386,7 @@ var init_DatePicker = __esm({
       dateOptions,
       required = true,
       isLoading = false,
-      isEmpty: isEmpty2 = false,
+      isEmpty = false,
       hasMore = false,
       onLoadMore
     }) => {
@@ -159843,7 +160400,7 @@ var init_DatePicker = __esm({
           /* @__PURE__ */ jsx("p", { className: "ab-text ab-text--muted ab-text--sm", children: "Loading available dates..." })
         ] });
       }
-      if (isEmpty2) {
+      if (isEmpty) {
         return /* @__PURE__ */ jsxs("div", { className: "ab-stack--sm", children: [
           /* @__PURE__ */ jsxs("label", { className: "ab-label", children: [
             "Select Date",
@@ -160394,7 +160951,7 @@ function buildBookingPaymentOptionViewModel(input) {
       };
     }
     default:
-      return assertNever7(input.option);
+      return assertNever8(input.option);
   }
 }
 function buildInstalmentSchedulePreview(input) {
@@ -160451,7 +161008,7 @@ function buildInstalmentSchedulePreview(input) {
       })));
     }
     default:
-      return assertNever7(input.option.plan);
+      return assertNever8(input.option.plan);
   }
 }
 function getPaymentCadenceLabel(plan) {
@@ -161204,7 +161761,7 @@ function pollingReducer(state, action) {
         case "timeout":
           return state;
         default:
-          return assertNever7(state);
+          return assertNever8(state);
       }
     case "polling-timed-out":
       return {
@@ -161213,7 +161770,7 @@ function pollingReducer(state, action) {
         error: new Error("Polling timed out")
       };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 var init_usePolling_state = __esm({
@@ -161394,7 +161951,7 @@ function bookingSubmissionReducer(state, action) {
         feedback: { tag: "idle" }
       };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 function selectIsSubmitting2(state) {
@@ -161726,7 +162283,7 @@ function validateFormData(data) {
   return errors;
 }
 var EMAIL_REGEX;
-var init_validation4 = __esm({
+var init_validation3 = __esm({
   "../blocks/src/system/runtime/shared/utils/validation.ts"() {
     EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
   }
@@ -161750,7 +162307,7 @@ var init_utils11 = __esm({
     init_scrollToBlock();
     init_themePortalRoot();
     init_urlParams();
-    init_validation4();
+    init_validation3();
     init_wizardSteps();
   }
 });
@@ -162795,7 +163352,7 @@ function eligibilityLookupReducer(state, action) {
         error: action.message
       };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 function existingRegistrationLookupReducer(state, action) {
@@ -162813,7 +163370,7 @@ function existingRegistrationLookupReducer(state, action) {
         registration: action.registration
       };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 var initialEligibilityLookupState, initialExistingRegistrationLookupState;
@@ -164462,7 +165019,7 @@ function validateFormData2(formData) {
   }
   return errors;
 }
-var init_validation5 = __esm({
+var init_validation4 = __esm({
   "../blocks/src/system/runtime/nodes/event-registration/validation.ts"() {
     "use client";
   }
@@ -165402,7 +165959,7 @@ var init_useEventRegistrationWizard = __esm({
     "use client";
     init_api();
     init_events2();
-    init_validation5();
+    init_validation4();
     init_hooks3();
     init_portalLogout();
     init_useWaitlistClaim();
@@ -166186,6 +166743,14 @@ var init_CourseRegistrationErrorBoundary = __esm({
     };
   }
 });
+function TeamMemberInlineList({
+  teamMembers
+}) {
+  return /* @__PURE__ */ jsx(Fragment, { children: teamMembers.map((teamMember, index2) => /* @__PURE__ */ jsxs(React56__default.Fragment, { children: [
+    index2 > 0 ? ", " : "",
+    teamMember.profilePath ? /* @__PURE__ */ jsx("a", { href: teamMember.profilePath, children: teamMember.name }) : teamMember.name
+  ] }, teamMember.id)) });
+}
 function CourseCard({
   course,
   isSelected,
@@ -166266,7 +166831,7 @@ function CourseSummary({
     teamMembers.length > 0 && /* @__PURE__ */ jsxs("div", { className: "cr-summary__venue", children: [
       /* @__PURE__ */ jsx("strong", { children: "Team:" }),
       " ",
-      teamMembers.map((teamMember) => teamMember.name).join(", ")
+      /* @__PURE__ */ jsx(TeamMemberInlineList, { teamMembers })
     ] }),
     showPrice && pricing.display.kind !== "unavailable" && /* @__PURE__ */ jsxs("p", { className: "cr-summary__price", children: [
       /* @__PURE__ */ jsx("strong", { children: pricing.selectableOptions.length > 0 ? "Pricing:" : "Price:" }),
@@ -168034,7 +168599,7 @@ function shopPassesMembershipsReducer(state, action) {
         returnNotice: null
       };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 function getOpenCheckout(state) {
@@ -168880,7 +169445,7 @@ function shopCheckoutReducer(state, action) {
         notice: action.notice
       };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 var initialShopCheckoutState;
@@ -169298,7 +169863,7 @@ function giftingClientReducer(state, action) {
         purchaseNotice: action.notice
       };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 function resolveGiftingPurchaseNotice(search, defaultSuccessMessage) {
@@ -173003,7 +173568,7 @@ function formSubmissionReducer(_state, action) {
     case "submission-failed":
       return { tag: "failed", message: action.message };
     default:
-      return assertNever7(action);
+      return assertNever8(action);
   }
 }
 var initialFormSubmissionState;
@@ -173737,32 +174302,14 @@ var init_repeaterFieldDefaults = __esm({
   "../block-form/src/widgets/RepeaterField/repeaterFieldDefaults.ts"() {
   }
 });
+
+// ../block-form/src/widgets/UrlField/urlFieldSchema.ts
 function buildUrlFieldSchema(field) {
-  const message2 = "Enter a valid web address";
-  const validator = (value) => {
-    if (!value) {
-      return !field.required;
-    }
-    if (field.allowRelative && value.startsWith("/")) {
-      return true;
-    }
-    try {
-      const parsed = new URL(value);
-      return ALLOWED_PROTOCOLS.includes(parsed.protocol);
-    } catch {
-      return false;
-    }
-  };
-  const base2 = z.string().trim().refine(validator, message2);
-  if (field.required) {
-    return base2.min(1, { message: "This field is required" });
-  }
-  return z.union([base2, z.literal("")]).optional().nullable();
+  return buildCanonicalFieldSchema(field);
 }
-var ALLOWED_PROTOCOLS;
 var init_urlFieldSchema = __esm({
   "../block-form/src/widgets/UrlField/urlFieldSchema.ts"() {
-    ALLOWED_PROTOCOLS = ["http:", "https:"];
+    init_canonicalValidation();
   }
 });
 
@@ -173841,18 +174388,14 @@ var init_dateTimeFieldDefaults = __esm({
   "../block-form/src/widgets/DateTimeField/dateTimeFieldDefaults.ts"() {
   }
 });
+
+// ../block-form/src/widgets/SlugField/slugFieldSchema.ts
 function buildSlugFieldSchema(field) {
-  const base2 = z.string().regex(SLUG_PATTERN2, `${field.label} must use lowercase letters, numbers, and dashes`);
-  const withLength = field.maxLength ? base2.max(field.maxLength, { message: `${field.label} must be at most ${field.maxLength} characters` }) : base2;
-  if (field.required) {
-    return withLength.min(1, { message: `${field.label} is required` });
-  }
-  return z.union([withLength, z.literal("")]).optional().nullable();
+  return buildCanonicalFieldSchema(field);
 }
-var SLUG_PATTERN2;
 var init_slugFieldSchema = __esm({
   "../block-form/src/widgets/SlugField/slugFieldSchema.ts"() {
-    SLUG_PATTERN2 = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
+    init_canonicalValidation();
   }
 });
 
@@ -173864,51 +174407,14 @@ var init_slugFieldDefaults = __esm({
   "../block-form/src/widgets/SlugField/slugFieldDefaults.ts"() {
   }
 });
+
+// ../block-form/src/widgets/LinkField/linkFieldSchema.ts
 function buildLinkFieldSchema(field) {
-  if (field.required) {
-    return linkSchema2;
-  }
-  return z.union([linkSchema2, z.null()]).optional();
+  return buildCanonicalFieldSchema(field);
 }
-var internalLinkSchema2, externalLinkSchema2, customLinkSchema2, pageLinkSchema2, entryLinkSchema2, linkSchema2;
 var init_linkFieldSchema = __esm({
   "../block-form/src/widgets/LinkField/linkFieldSchema.ts"() {
-    internalLinkSchema2 = z.object({
-      kind: z.literal("internal"),
-      routeId: z.string().min(1),
-      entityId: z.string().min(1),
-      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()
-    }).passthrough();
-    externalLinkSchema2 = z.object({
-      kind: z.literal("external"),
-      href: z.string().min(1)
-    }).passthrough();
-    customLinkSchema2 = z.object({
-      kind: z.literal("url"),
-      href: z.string().min(1)
-    }).passthrough();
-    pageLinkSchema2 = z.object({
-      kind: z.literal("page"),
-      identifier: z.string().min(1)
-    }).passthrough();
-    entryLinkSchema2 = z.object({
-      kind: z.literal("entry"),
-      contentType: z.string().min(1),
-      identifier: z.string().min(1)
-    }).passthrough();
-    linkSchema2 = z.union([
-      internalLinkSchema2,
-      externalLinkSchema2,
-      customLinkSchema2,
-      pageLinkSchema2,
-      entryLinkSchema2
-    ]);
+    init_canonicalValidation();
   }
 });
 
@@ -173926,6 +174432,55 @@ var init_linkFieldDefaults = __esm({
   "../block-form/src/widgets/LinkField/linkFieldDefaults.ts"() {
   }
 });
+function buildRichTextSchema(options) {
+  let schema = RichTextValueSchema;
+  if (options?.required) {
+    const label = options.label ?? "This field";
+    schema = schema.refine(
+      (val) => {
+        const doc3 = isRecord5(val) && "doc" in val ? val.doc : val;
+        const content = isRecord5(doc3) ? doc3.content : void 0;
+        if (!Array.isArray(content) || content.length === 0) return false;
+        const first2 = content[0];
+        if (content.length === 1 && isRecord5(first2) && first2.type === "paragraph" && (!("content" in first2) || first2.content == null)) {
+          return false;
+        }
+        return true;
+      },
+      {
+        message: `${label} is required`
+      }
+    );
+  }
+  return schema;
+}
+var TipTapMarkSchema, TipTapNodeSchema, RichTextValueSchema;
+var init_richTextSchema = __esm({
+  "../blocks/src/system/manifest/richTextSchema.ts"() {
+    init_typeGuards2();
+    TipTapMarkSchema = z.object({
+      type: z.string(),
+      attrs: z.record(z.string(), z.unknown()).optional()
+    });
+    TipTapNodeSchema = z.lazy(
+      () => z.object({
+        type: z.string(),
+        content: z.array(TipTapNodeSchema).optional(),
+        text: z.string().optional(),
+        attrs: z.record(z.string(), z.unknown()).optional(),
+        marks: z.array(TipTapMarkSchema).optional()
+      })
+    );
+    RichTextValueSchema = z.union([
+      // New format: TipTap document directly
+      TipTapNodeSchema,
+      // Legacy format: wrapped in { doc: {...} }
+      z.object({
+        doc: TipTapNodeSchema
+      })
+    ]);
+  }
+});
 function buildRichTextFieldSchema(config) {
   const schema = buildRichTextSchema({
     required: config.required,
@@ -173956,30 +174511,14 @@ var init_richTextFieldDefaults = __esm({
     };
   }
 });
+
+// ../block-form/src/widgets/MediaField/mediaFieldSchema.ts
 function buildMediaFieldSchema(config) {
-  let schema = MediaValueSchema.nullable();
-  if (config.required) {
-    schema = schema.refine((val) => val !== null, {
-      message: `${config.label} is required`
-    });
-  }
-  return schema;
+  return buildCanonicalFieldSchema(config);
 }
-var MediaValueSchema;
 var init_mediaFieldSchema = __esm({
   "../block-form/src/widgets/MediaField/mediaFieldSchema.ts"() {
-    MediaValueSchema = z.object({
-      kind: z.enum(["image", "video", "audio", "document", "spreadsheet", "archive"]),
-      url: z.string().url(),
-      title: z.string().optional(),
-      alt: z.string().optional(),
-      caption: z.string().optional(),
-      credit: z.string().optional(),
-      width: z.number().optional(),
-      height: z.number().optional(),
-      size: z.number().optional(),
-      mimeType: z.string().optional()
-    });
+    init_canonicalValidation();
   }
 });
 
@@ -173991,15 +174530,14 @@ var init_mediaFieldDefaults = __esm({
   "../block-form/src/widgets/MediaField/mediaFieldDefaults.ts"() {
   }
 });
+
+// ../block-form/src/widgets/ReferenceField/referenceFieldSchema.ts
 function buildReferenceFieldSchema(field, _ctx) {
-  const schema = z.string();
-  if (field.required) {
-    return schema.refine((value) => value.trim().length > 0, "This field is required");
-  }
-  return schema.optional().nullable().or(z.literal(""));
+  return buildCanonicalFieldSchema(field);
 }
 var init_referenceFieldSchema = __esm({
   "../block-form/src/widgets/ReferenceField/referenceFieldSchema.ts"() {
+    init_canonicalValidation();
   }
 });
 
@@ -192758,7 +193296,7 @@ var init_PreviewRichTextEditor = __esm({
       const isEditingRef = useRef(false);
       const initialDoc = normaliseDoc(value ?? doc3);
       const chosenVariant = variant ?? "full";
-      const { editor, isEmpty: isEmpty2, config } = useRichTextEditor({
+      const { editor, isEmpty, config } = useRichTextEditor({
         content: initialDoc,
         editable: true,
         variant: chosenVariant
@@ -192835,7 +193373,7 @@ var init_PreviewRichTextEditor = __esm({
               {
                 editor,
                 config,
-                isEmpty: isEmpty2,
+                isEmpty,
                 className: `relative w-full min-h-[30px] rounded border border-dashed ${showAffordance ? "border-slate-400/75 bg-white/5" : "border-transparent bg-transparent"}`,
                 contentClassName: "cursor-text",
                 placeholderClassName: "text-gray-400",
@@ -193690,7 +194228,9 @@ function isSameLinkValue(a2, b3) {
   if (!a2 || !b3 || a2.kind !== b3.kind) return false;
   switch (a2.kind) {
     case "internal":
-      return b3.kind === "internal" && a2.routeId === b3.routeId && a2.entityId === b3.entityId && a2.entityType === b3.entityType && a2.href === b3.href && a2.title === b3.title && a2.typeLabel === b3.typeLabel && a2.contentTypeKey === b3.contentTypeKey && a2.contentTypeName === b3.contentTypeName && a2.updatedAt === b3.updatedAt;
+      if (b3.kind !== "internal" || a2.routeId !== b3.routeId) return false;
+      if (!isInternalResolvedLinkValue(a2) || !isInternalResolvedLinkValue(b3)) return true;
+      return a2.entityId === b3.entityId && a2.entityType === b3.entityType && a2.href === b3.href && a2.title === b3.title && a2.typeLabel === b3.typeLabel && a2.contentTypeKey === b3.contentTypeKey && a2.contentTypeName === b3.contentTypeName && a2.updatedAt === b3.updatedAt;
     case "page":
       return b3.kind === "page" && a2.identifier === b3.identifier;
     case "entry":
@@ -193709,6 +194249,7 @@ function getDisplayTitle2(item) {
 var init_utils22 = __esm({
   "../editor-blocks/src/widgets/link/utils.ts"() {
     init_navigation2();
+    init_src6();
   }
 });
 function getActiveTab(value) {
@@ -194017,6 +194558,12 @@ function LinkTriggerContent({ value }) {
     return /* @__PURE__ */ jsx("span", { className: "text-muted-foreground", children: "Select a link..." });
   }
   if (value.kind === "internal") {
+    if (!isInternalResolvedLinkValue(value)) {
+      return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-1 items-center gap-2", children: [
+        /* @__PURE__ */ jsx("span", { className: "truncate font-medium", title: value.routeId, children: "Internal route" }),
+        /* @__PURE__ */ jsx(Badge2, { variant: "secondary", className: "shrink-0", children: "Internal" })
+      ] });
+    }
     return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-1 items-center gap-2", children: [
       /* @__PURE__ */ jsx("span", { className: "truncate font-medium", title: value.title || void 0, children: value.title || "Untitled" }),
       /* @__PURE__ */ jsx(Badge2, { variant: "secondary", className: "shrink-0", children: value.typeLabel })
@@ -194113,6 +194660,7 @@ function LinkWidget({
 var init_LinkWidget = __esm({
   "../editor-blocks/src/widgets/link/LinkWidget.tsx"() {
     "use client";
+    init_src6();
     init_src();
     init_lucide_react();
     init_client4();
@@ -194541,8 +195089,8 @@ function unwrapValue(value) {
   if (typeof value === "string") {
     return value;
   }
-  if (isObjectRecord(value)) {
-    if (isObjectRecord(value.doc)) {
+  if (isObjectRecord2(value)) {
+    if (isObjectRecord2(value.doc)) {
       return value.doc;
     }
     if (typeof value.type === "string") {
@@ -197404,9 +197952,9 @@ function blockSaveabilityEqual(left, right) {
   if (left.issues.length !== right.issues.length) {
     return false;
   }
-  return left.issues.every((issue, index2) => {
+  return left.issues.every((issue2, index2) => {
     const nextIssue = right.issues[index2];
-    return nextIssue?.fieldPath === issue.fieldPath && nextIssue.message === issue.message;
+    return nextIssue?.fieldPath === issue2.fieldPath && nextIssue.message === issue2.message;
   });
 }
 var init_BlockForm = __esm({
@@ -200522,38 +201070,38 @@ var internalLinkPayloadSchema = z.object({
   contentTypeName: z.string().nullable().optional(),
   updatedAt: z.string().nullable().optional()
 }).passthrough();
-var externalLinkSchema3 = z.object({
+var externalLinkSchema2 = z.object({
   kind: z.literal("external"),
   // Navigation external links are expected to be absolute URLs.
   href: z.string().url()
 });
-var customLinkSchema3 = z.object({
+var customLinkSchema2 = z.object({
   kind: z.literal("url"),
   href: z.string().min(1)
 });
-var pageLinkSchema3 = z.object({
+var pageLinkSchema2 = z.object({
   kind: z.literal("page"),
   identifier: z.string().min(1)
 });
-var entryLinkSchema3 = z.object({
+var entryLinkSchema2 = z.object({
   kind: z.literal("entry"),
   contentType: z.string().min(1),
   identifier: z.string().min(1)
 });
 var linkPayloadSchema = z.discriminatedUnion("kind", [
   internalLinkPayloadSchema,
-  pageLinkSchema3,
-  entryLinkSchema3,
-  externalLinkSchema3,
-  customLinkSchema3,
+  pageLinkSchema2,
+  entryLinkSchema2,
+  externalLinkSchema2,
+  customLinkSchema2,
   portalLinkPayloadSchema,
   cartLinkPayloadSchema
 ]);
 var navigationLinkInputSchemaOptions = [
-  pageLinkSchema3,
-  entryLinkSchema3,
-  externalLinkSchema3,
-  customLinkSchema3,
+  pageLinkSchema2,
+  entryLinkSchema2,
+  externalLinkSchema2,
+  customLinkSchema2,
   portalLinkPayloadSchema,
   cartLinkPayloadSchema
 ];
@@ -201317,11 +201865,11 @@ siteBannerSettingsSchema.superRefine((value, ctx) => {
     return;
   }
   const analysis = analyzeSiteBannerBody(value.body);
-  for (const issue of analysis.issues) {
+  for (const issue2 of analysis.issues) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
       path: ["body"],
-      message: siteBannerBodyIssueMessage(issue)
+      message: siteBannerBodyIssueMessage(issue2)
     });
   }
 });
@@ -201355,8 +201903,8 @@ function analyzeSiteBannerBody(body) {
     issues
   };
 }
-function siteBannerBodyIssueMessage(issue) {
-  switch (issue) {
+function siteBannerBodyIssueMessage(issue2) {
+  switch (issue2) {
     case "empty":
       return "Banner message is required when the banner is enabled.";
     case "too-many-paragraphs":
@@ -201761,7 +202309,7 @@ function previewCustomizeHistoryEntryFromAction(editorModel, action) {
       };
     }
     default:
-      return assertNever5(action, "Unhandled preview customize action");
+      return assertNever6(action, "Unhandled preview customize action");
   }
 }
 function previewCustomizeUndoActionForEntry(entry) {
@@ -201802,7 +202350,7 @@ function previewCustomizeActionForEntryValue(entry, valueKey) {
       };
     }
     default:
-      return assertNever5(entry, "Unhandled preview customize history entry");
+      return assertNever6(entry, "Unhandled preview customize history entry");
   }
 }
 function supportedPinnedChoiceValue(choice) {
@@ -201824,7 +202372,7 @@ function previewCustomizeHistoryEntryStillApplies(entry, editorModel) {
         (boundary) => boundary.boundaryId === entry.boundaryId && boundary.previousBlockId === entry.previousBlockId && boundary.nextBlockId === entry.nextBlockId
       );
     default:
-      return assertNever5(entry, "Unhandled preview customize history entry");
+      return assertNever6(entry, "Unhandled preview customize history entry");
   }
 }
 function previewCustomizeHistoryEntryEquals(left, right) {
@@ -201838,7 +202386,7 @@ function previewCustomizeHistoryEntryEquals(left, right) {
     case "boundary":
       return right.kind === "boundary" && left.boundaryId === right.boundaryId && left.previousBlockId === right.previousBlockId && left.nextBlockId === right.nextBlockId && left.fromBoundaryOptionId === right.fromBoundaryOptionId && left.toBoundaryOptionId === right.toBoundaryOptionId;
     default:
-      return assertNever5(left, "Unhandled preview customize history entry");
+      return assertNever6(left, "Unhandled preview customize history entry");
   }
 }
 
@@ -201879,7 +202427,7 @@ function previewCustomizeWorkflowPageState(workflow) {
     case "loaded":
       return workflow.pageState;
     default:
-      return assertNever5(workflow, "Unhandled preview customize workflow state");
+      return assertNever6(workflow, "Unhandled preview customize workflow state");
   }
 }
 function beginPreviewCustomizeApply(workflow, action) {
@@ -201974,7 +202522,7 @@ function confirmPreviewCustomizeMutation(workflow, response) {
     case "stale":
       return workflow;
     default:
-      return assertNever5(workflow.mutation, "Unhandled preview customize mutation");
+      return assertNever6(workflow.mutation, "Unhandled preview customize mutation");
   }
 }
 function rejectPreviewCustomizeMutation(previousWorkflow, outcome) {
@@ -202008,7 +202556,7 @@ function previewCustomizeFailureMessage(workflow) {
     case "redoing":
       return null;
     default:
-      return assertNever5(workflow.mutation, "Unhandled preview customize mutation");
+      return assertNever6(workflow.mutation, "Unhandled preview customize mutation");
   }
 }
 function skippedPreviewCustomizeOutcome(reason) {
@@ -202040,7 +202588,7 @@ function skippedPreviewCustomizeMessage(reason) {
     case "cannot-redo":
       return "No design choice is available to redo.";
     default:
-      return assertNever5(reason, "Unhandled preview customize skip reason");
+      return assertNever6(reason, "Unhandled preview customize skip reason");
   }
 }
 function skipReasonForNewMutation(workflow) {
@@ -202063,7 +202611,7 @@ function isPendingMutation(mutation) {
     case "stale":
       return false;
     default:
-      return assertNever5(mutation, "Unhandled preview customize mutation");
+      return assertNever6(mutation, "Unhandled preview customize mutation");
   }
 }
 function confirmedLoadedState(current, response) {
@@ -202138,7 +202686,7 @@ function applyPreviewCustomizeActionToLoadedState(state, action) {
         }
       };
     default:
-      return assertNever5(action, "Unhandled preview customize action");
+      return assertNever6(action, "Unhandled preview customize action");
   }
 }
 function optimisticBoundaryBreakChoice(editorModel, boundary, action) {
@@ -202156,7 +202704,7 @@ function optimisticBoundaryBreakChoice(editorModel, boundary, action) {
         effectiveValue: autoBoundaryEffectiveValue(editorModel, boundary)
       };
     default:
-      return assertNever5(action, "Unhandled optimistic boundary action");
+      return assertNever6(action, "Unhandled optimistic boundary action");
   }
 }
 function autoBoundaryEffectiveValue(editorModel, boundary) {
@@ -202416,7 +202964,7 @@ function pageDesignEditorActionForPersistence(action) {
     case "set-boundary":
       return action;
     default:
-      return assertNever5(action, "Unhandled page design editor action");
+      return assertNever6(action, "Unhandled page design editor action");
   }
 }
 function classifyApplyActionError(error) {
@@ -202459,7 +203007,7 @@ function blockIdForRuntimePatch(action) {
     case "reset-boundary":
       return action.previousBlockId;
     default:
-      return assertNever5(action, "Unhandled runtime patch action");
+      return assertNever6(action, "Unhandled runtime patch action");
   }
 }
 function currentLocalBlockContent(uiStore, targetBlockId) {
@@ -205114,7 +205662,7 @@ function boundaryBreakDisplay(boundary) {
         resetLabel: "Use default break"
       };
     default:
-      return assertNever5(boundary.breakChoice, "Unhandled boundary break choice");
+      return assertNever6(boundary.breakChoice, "Unhandled boundary break choice");
   }
 }
 function formatBlockKindLabel2(blockKind) {