@riverbankcms/sdk 0.60.7 → 0.60.11

package/dist/cli/index.mjs

@@ -1522,15 +1522,6 @@ var init_augmentManifest = __esm({
   "../blocks/src/system/manifest/augmentManifest.ts"() {
   }
 });
-
-// ../blocks/src/lib/typeGuards.ts
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var init_typeGuards = __esm({
-  "../blocks/src/lib/typeGuards.ts"() {
-  }
-});
 var VARIANT_ROLES, cornerStyleSchema, shadowSizeSchema, textTransformSchema, fontWeightSchema, buttonTypographySchema, letterSpacingSchema, hoverTransformSchema, hoverColorSchema, buttonPaddingPresetSchema, gradientStyleSchema, gradientSharpnessSchema, prioritySchema, buttonSizeNameSchema, PADDING_TOKEN_PATTERN, paddingShorthandSchema, buttonSizeConfigSchema, buttonSizesSchema, buttonGlobalSettingsSchema, gradientDirectionSchema, buttonBackgroundSchema, effectApplicationSchema, buttonBorderSchema, variantShadowSchema, variantEffectsSchema, variantSizeOverridesSchema, buttonVariantSchema, buttonSystemSchema;
 var init_types2 = __esm({
   "../theme-core/src/buttons/types.ts"() {
@@ -2300,6 +2291,13 @@ var init_personalities = __esm({
   }
 });
 
+// ../theme-core/src/buttons/classNames.ts
+var init_classNames = __esm({
+  "../theme-core/src/buttons/classNames.ts"() {
+    init_types2();
+  }
+});
+
 // ../theme-core/src/tokens/resolver.ts
 var init_resolver = __esm({
   "../theme-core/src/tokens/resolver.ts"() {
@@ -2418,6 +2416,7 @@ var init_generateDefaultButtonSystem = __esm({
 var init_generateButtonCss = __esm({
   "../theme-core/src/buttons/generateButtonCss.ts"() {
     init_types2();
+    init_classNames();
     init_resolver();
     init_generateEffectsCSS();
     init_constants();
@@ -2448,6 +2447,7 @@ var init_core = __esm({
 var init_buttons = __esm({
   "../theme-core/src/buttons/index.ts"() {
     init_types2();
+    init_classNames();
     init_generateButtonCss();
     init_generateDefaultButtonSystem();
     init_constants();
@@ -8330,9 +8330,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
         }))
       );
     }
@@ -8622,6 +8622,15 @@ var init_colorConversion = __esm({
   }
 });
 
+// ../blocks/src/lib/typeGuards.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_typeGuards = __esm({
+  "../blocks/src/lib/typeGuards.ts"() {
+  }
+});
+
 // ../theme-core/src/responsiveDisplay.ts
 function mobileOnlyDisplay(display) {
   return `${BASE_DISPLAY_CLASSES[display]} rb-lg-hidden`;
@@ -11191,7 +11200,7 @@ var init_shared6 = __esm({
 });
 
 // ../blocks/src/system/runtime/api/creditProducts.ts
-function assertNever3(value) {
+function assertNever4(value) {
   throw new Error(`Unhandled credit product case: ${String(value)}`);
 }
 function useCasesFromModules(modules) {
@@ -11224,7 +11233,7 @@ function getCreditProductCreditUnit(useCase) {
         perCreditSuffix: "credit"
       };
     default:
-      return assertNever3(useCase);
+      return assertNever4(useCase);
   }
 }
 function deriveCreditProductLabels(products, options = {}) {
@@ -20792,11 +20801,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)
     });
   }
 });
@@ -20830,8 +20839,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":
@@ -21083,324 +21092,35 @@ function isNavigationMenuValidationItem(value) {
   if (!isRecord(value)) return false;
   return typeof value.label === "string";
 }
-var Rfc6902PatchOp = z.discriminatedUnion("op", [
-  // Standard RFC-6902 operations
-  z.object({
-    op: z.literal("add"),
-    path: z.string(),
-    value: z.unknown()
-  }),
-  z.object({
-    op: z.literal("remove"),
-    path: z.string()
-  }),
-  z.object({
-    op: z.literal("replace"),
-    path: z.string(),
-    value: z.unknown()
-  }),
-  z.object({
-    op: z.literal("move"),
-    from: z.string(),
-    path: z.string()
-  }),
-  z.object({
-    op: z.literal("copy"),
-    from: z.string(),
-    path: z.string()
-  }),
-  // Block-level operations (Phase 2)
-  z.object({
-    op: z.literal("add_block"),
-    blockKind: z.string(),
-    afterBlockId: z.string().nullable(),
-    content: z.record(z.string(), z.unknown()),
-    rationale: z.string()
-  }),
-  z.object({
-    op: z.literal("delete_block"),
-    blockId: z.string(),
-    rationale: z.string()
-  }),
-  z.object({
-    op: z.literal("reorder_block"),
-    blockId: z.string(),
-    afterBlockId: z.string().nullable(),
-    rationale: z.string()
-  })
-]);
-z.object({
-  request: z.string().min(1).max(2e3)
-});
-var MultiPagePatchEnvelope = z.object({
-  pageId: z.string(),
-  blockId: z.string().optional(),
-  // Not present for page-level ops
-  blockKind: z.string().optional(),
-  blockPurpose: z.string().optional().nullable(),
-  ops: z.array(Rfc6902PatchOp),
-  rationale: z.string(),
-  currentContent: z.record(z.string(), z.unknown()).optional()
-});
-z.object({
-  patches: z.array(MultiPagePatchEnvelope),
-  assistantMessage: z.string(),
-  pagesModified: z.number(),
-  toolCallsUsed: z.number()
-});
-
-// ../blocks/src/system/manifest/registry.ts
-var REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@riverbankcms/blocks/manifest-registry");
-var isVitest = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.VITEST === "true";
-var globalScope = globalThis;
-var manifestStore = isVitest ? /* @__PURE__ */ new Map() : globalScope[REGISTRY_SYMBOL] ??= /* @__PURE__ */ new Map();
-function registerManifest(manifest) {
-  manifestStore.set(manifest.name, manifest);
-  return manifest;
-}
-
-// ../blocks/src/system/manifest/validation.ts
-init_schema2();
-
-// ../blocks/src/system/manifest/richTextSchema.ts
-init_typeGuards();
-var TipTapMarkSchema = z.object({
-  type: z.string(),
-  attrs: z.record(z.string(), z.unknown()).optional()
-});
-var 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()
-  })
-);
-var RichTextValueSchema = z.union([
-  // New format: TipTap document directly
-  TipTapNodeSchema,
-  // Legacy format: wrapped in { doc: {...} }
-  z.object({
-    doc: TipTapNodeSchema
-  })
-]);
-function buildRichTextSchema(options) {
-  let schema = RichTextValueSchema;
-  return schema;
-}
-
-// ../blocks/src/system/manifest/validation.ts
-function isEmpty(value) {
-  if (typeof value === "string" && value.trim() === "") return true;
-  if (value === null || value === void 0) return true;
-  if (Array.isArray(value) && value.length === 0) return true;
-  if (isEmptyRichTextDoc(value)) return true;
-  return false;
-}
-function isEmptyRichTextDoc(value) {
-  if (!value || typeof value !== "object") return false;
-  const obj = value;
-  const doc = "doc" in obj ? obj.doc : obj;
-  if (!doc || typeof doc !== "object") return false;
-  const docObj = doc;
-  if (docObj.type !== "doc") return false;
-  const content = docObj.content;
-  if (!Array.isArray(content) || content.length === 0) return true;
-  if (content.length === 1) {
-    const first = content[0];
-    if (first.type === "paragraph" && (!first.content || first.content.length === 0)) {
-      return true;
-    }
-  }
-  return false;
-}
-function 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;
-  }
-  return result;
-}
-function createManifestValidator(manifestOrFields, options = {}) {
-  const allowNull = options.allowNull ?? true;
-  const isDraft = options.mode === "draft";
-  const allowIncomplete = isDraft || (options.allowIncomplete ?? false);
-  const shape = {};
-  const fields3 = Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? [];
-  for (const field of fields3) {
-    shape[field.id] = buildFieldSchema(field, allowNull, allowIncomplete);
-  }
-  const baseSchema = z.object(shape).catchall(z.unknown()).passthrough();
-  if (isDraft) {
-    return z.preprocess(preprocessEmptyValues, baseSchema);
-  }
-  return baseSchema;
-}
-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;
-    }
-    case "boolean":
-      schema = z.boolean();
-      break;
-    case "slug":
-      schema = buildSlugSchema(field);
-      break;
-    case "url":
-      schema = buildUrlSchema(field);
-      break;
-    case "link":
-      schema = buildLinkSchema();
-      break;
-    case "select":
-      schema = buildSelectSchema(field);
-      break;
-    case "reference":
-      schema = buildReferenceSchema(field);
-      break;
-    case "repeater":
-      schema = buildRepeaterSchema(field, allowNull, allowIncomplete);
-      break;
-    case "group":
-      schema = buildGroupSchema(field, allowNull, allowIncomplete);
-      break;
-    default:
-      schema = z.unknown();
-      break;
-  }
-  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 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 re = new RegExp(ui.pattern);
-        schema = schema.regex(
-          re,
-          `${field.label} is not in the right format`
-        );
-      } catch {
-      }
-    }
-    if (field.maxLength) {
-      schema = schema.max(
-        field.maxLength,
-        `${field.label} must be ${field.maxLength} characters or less`
-      );
-    }
-    if (field.required) {
-      schema = schema.min(1, { message: `${field.label} is required` }).refine((v) => v.trim().length > 0, { message: `${field.label} is required` });
-    }
-  }
-  return schema;
-}
-function buildRichTextSchema2() {
-  return buildRichTextSchema();
-}
-var SLUG_PATTERN = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
-function buildSlugSchema(field) {
-  const message = `${field.label} can only use lowercase letters, numbers, and dashes`;
-  let schema = buildFriendlyStringSchema(field).regex(SLUG_PATTERN, message);
-  if (field.maxLength) {
-    schema = schema.max(
-      field.maxLength,
-      `${field.label} must be ${field.maxLength} characters or less`
-    );
-  }
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
-  }
-  return schema;
-}
-var ALLOWED_URL_PROTOCOLS = ["http:", "https:"];
-function buildUrlSchema(field) {
-  const message = "Enter a valid web address";
-  const validate = (value) => {
-    if (!value) {
-      return !field.required;
-    }
-    if (field.allowRelative && value.startsWith("/")) {
-      return true;
-    }
-    try {
-      const parsed = new URL(value);
-      return ALLOWED_URL_PROTOCOLS.includes(
-        parsed.protocol
-      );
-    } catch {
-      return false;
-    }
-  };
-  let schema = buildFriendlyStringSchema(field).trim().refine(validate, message);
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
-  }
-  return schema;
-}
 var nullableString = z.union([z.string().min(1), z.null()]);
-var internalLinkSchema = z.object({
+var resolvedInternalLinkKeys = ["entityId", "entityType", "href", "title", "typeLabel"];
+var 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"
+  });
+});
+var internalResolvedLinkSchema = 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(),
+  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();
+var internalLinkSchema = z.union([
+  internalResolvedLinkSchema,
+  internalRouteOnlyLinkSchema
+]);
 var externalLinkSchema2 = z.object({
   kind: z.literal("external"),
   href: z.string().min(1)
@@ -21425,84 +21145,605 @@ var linkSchema = z.union([
   pageLinkSchema2,
   entryLinkSchema2
 ]);
-function buildLinkSchema() {
-  return linkSchema;
+
+// ../blocks/src/system/manifest/fieldValidation/index.ts
+init_schema2();
+var TEL_RE = /^[+()0-9\s-]{3,}$/;
+var SLUG_PATTERN = /^(?:[a-z0-9]+(?:-[a-z0-9]+)*)(?:\/(?:[a-z0-9]+(?:-[a-z0-9]+)*))*$/;
+var ALLOWED_URL_PROTOCOLS = ["http:", "https:"];
+function assertNever2(value) {
+  throw new Error(`Unhandled field validation variant: ${JSON.stringify(value)}`);
 }
-function assertNeverSelectSource2(value) {
-  throw new Error(`Unhandled select source: ${JSON.stringify(value)}`);
+function validationContext(options = {}) {
+  const isDraft = options.mode === "draft";
+  return {
+    allowNull: options.allowNull ?? true,
+    allowIncomplete: isDraft || (options.allowIncomplete ?? false)
+  };
+}
+function formatFieldPath(path21) {
+  return path21.map((segment) => String(segment)).join(".");
+}
+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 assertNever2(issue2);
+  }
+}
+function pluralize(label, count) {
+  if (count === 1) return label;
+  return label.endsWith("s") ? label : `${label}s`;
+}
+function deriveFieldValidationPlan(field, path21 = [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, path21, 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, path21, 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, path21, 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, path21, required, constraints);
+    }
+    case "url":
+      return makePlan("string", "string", field, path21, required, commonConstraints(
+        required,
+        { kind: "textType" },
+        { kind: "urlFormat", allowRelative: Boolean(field.allowRelative) }
+      ));
+    case "reference":
+      return makePlan("string", "string", field, path21, required, commonConstraints(required, { kind: "referenceText" }));
+    case "date":
+    case "time":
+    case "datetime":
+      return makePlan("string", "string", field, path21, required, commonConstraints(required, { kind: "textType" }));
+    case "select":
+      return makePlan("select", "select", field, path21, required, commonConstraints(required, {
+        kind: "selectOption",
+        source: resolveSelectConstraintSource(field),
+        multiple: Boolean(field.multiple)
+      }));
+    case "richText":
+      return makePlan("richText", "object", field, path21, required, commonConstraints(required, { kind: "richTextDoc" }));
+    case "media":
+      return makePlan("media", "object", field, path21, required, commonConstraints(required, { kind: "mediaObject" }));
+    case "link":
+      return makePlan("link", "object", field, path21, required, commonConstraints(required, { kind: "linkObject" }));
+    case "boolean":
+      return makePlan("boolean", "boolean", field, path21, required, requiredConstraints(required));
+    case "repeater":
+      return {
+        ...makePlan("repeater", "array", field, path21, required, commonConstraints(required, { kind: "arrayType" })),
+        ...field.polymorphic && field.itemTypes ? { repeatedItemVariants: deriveRepeatedItemVariants(field, [...path21, 0]) } : { repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path21, 0]) },
+        constraints: withRepeaterItemConstraints(field, commonConstraints(required, { kind: "arrayType" }))
+      };
+    case "group":
+    case "modal":
+      return {
+        ...makePlan("group", "object", field, path21, required, requiredConstraints(required)),
+        children: deriveNestedFieldPlans(field.schema?.fields ?? [], path21),
+        allowNullChildren: field.type === "group" && field.ui?.widget === "locationPicker"
+      };
+    case "tabGroup":
+      return {
+        ...makePlan("group", "object", field, path21, required, requiredConstraints(required)),
+        children: field.tabs.flatMap((tab) => deriveNestedFieldPlans(tab.fields, path21))
+      };
+    case "presetOrCustom":
+    case "contentTypeSelect":
+    case "entryPicker":
+      return makePlan("passthrough", "unknown", field, path21, false, []);
+    default:
+      return assertNever2(field);
+  }
+}
+function commonConstraints(required, ...specific) {
+  return required ? [{ kind: "required" }, ...specific] : [...specific];
+}
+function requiredConstraints(required) {
+  return required ? [{ kind: "required" }] : [];
+}
+function makePlan(kind, valueKind, field, path21, required, constraints) {
+  return {
+    kind,
+    valueKind,
+    fieldId: field.id,
+    label: field.label,
+    fieldType: field.type,
+    path: path21,
+    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 buildSelectSchema(field) {
+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);
-  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}`
-        );
-      }
+  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 assertNever2(source);
+  }
+}
+function normalizeFieldValue(plan, value, ctx) {
+  switch (plan.kind) {
+    case "number":
+      return normalizeNumberInput(value, ctx.allowNull);
+    case "string":
+      return acceptsOptionalBlankAsMissing(plan, value) ? void 0 : value;
+    case "group":
+      return normalizeObjectChildren(plan.children, value, childValidationContext(plan, ctx));
+    case "repeater":
+      return normalizeRepeaterItems(plan, value, ctx);
+    case "boolean":
+    case "richText":
+    case "media":
+    case "link":
+    case "select":
+    case "passthrough":
+      return value;
+    default:
+      return assertNever2(plan);
+  }
+}
+function normalizeObjectChildren(children, value, ctx) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value;
+  const normalized = { ...value };
+  for (const child of children) {
+    normalized[child.fieldId] = normalizeFieldValue(child, normalized[child.fieldId], ctx);
+  }
+  return normalized;
+}
+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":
+      return typeof value === "boolean" ? [] : [issue(plan, "wrongType", { expected: "a true/false value" })];
+    case "select":
+      return validateSelectPlan(plan, value);
+    case "richText":
+      return isValidRichTextDoc(value) ? [] : [issue(plan, "invalidRichText")];
+    case "media":
+      return isPlainObject(value) ? [] : [issue(plan, "invalidMedia")];
+    case "link":
+      return linkSchema.safeParse(value).success ? [] : [issue(plan, "invalidLink")];
+    case "repeater":
+      return validateRepeaterPlan(plan, value, ctx);
+    case "group":
+      return validateGroupPlan(plan, value, ctx);
+    case "passthrough":
+      return [];
+    default:
+      return assertNever2(plan);
+  }
+}
+function shouldRequireValue(plan, value, ctx) {
+  if (!plan.required || ctx.allowIncomplete) return false;
+  if (value === null && ctx.allowNull) return false;
+  return true;
+}
+function acceptsOptionalNullValue(plan) {
+  return !plan.required && (plan.kind === "media" || plan.kind === "number");
+}
+function isMissingForPlan(plan, value) {
+  if (value === void 0) return true;
+  if (value === null) return plan.required;
+  if (typeof value === "string" && value.trim() === "") return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+function validateStringPlan(plan, value) {
+  if (typeof value !== "string") return [issue(plan, "wrongType", { expected: "text" })];
+  return plan.constraints.flatMap((constraint) => validateStringConstraint(plan, constraint, value));
+}
+function validateStringConstraint(plan, constraint, value) {
+  switch (constraint.kind) {
+    case "required":
+    case "textType":
+    case "referenceText":
+      return [];
+    case "maxLength":
+      return value.length > constraint.maximum ? [issue(plan, "tooLong", { maximum: constraint.maximum })] : [];
+    case "emailFormat":
+      return z.email().safeParse(value).success ? [] : [issue(plan, "invalidEmail")];
+    case "phoneFormat":
+      return TEL_RE.test(value) ? [] : [issue(plan, "invalidPhone")];
+    case "patternFormat": {
+      const re = compilePattern(constraint.pattern);
+      return re && !re.test(value) ? [issue(plan, "invalidPattern")] : [];
+    }
+    case "urlFormat":
+      return isValidUrl(value, constraint.allowRelative) ? [] : [issue(plan, "invalidUrl")];
+    case "slugFormat":
+      return SLUG_PATTERN.test(value) ? [] : [issue(plan, "invalidSlug")];
+    default:
+      return assertNever2(constraint);
+  }
+}
+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 assertNever2(constraint);
+  }
+}
+function validateSelectPlan(plan, value) {
+  const constraint = plan.constraints.find((candidate) => candidate.kind === "selectOption");
+  if (!constraint || constraint.source.kind === "runtime") return [];
+  return isValidSelectValue(value, constraint.source.values, constraint.multiple) ? [] : [issue(plan, "invalidOption")];
+}
+function validateRepeaterPlan(plan, value, ctx) {
+  if (!Array.isArray(value)) return [issue(plan, "wrongType", { expected: "a list" })];
+  const constraintIssues = plan.constraints.flatMap((constraint) => {
+    switch (constraint.kind) {
+      case "required":
+      case "arrayType":
+        return [];
+      case "minItems":
+        return value.length < constraint.minimum ? [issue(plan, "tooFewItems", { minimum: constraint.minimum, itemLabel: "item" })] : [];
+      case "maxItems":
+        return value.length > constraint.maximum ? [issue(plan, "tooManyItems", { maximum: constraint.maximum, itemLabel: "item" })] : [];
       default:
-        return assertNeverSelectSource2(source);
+        return assertNever2(constraint);
     }
-  })();
-  if (field.multiple) {
-    const arraySchema = z.array(singleValueSchema);
-    return field.required ? arraySchema.min(1, { message: "This field is required" }) : arraySchema.nullable();
-  }
-  return field.required ? singleValueSchema : singleValueSchema.nullable();
+  });
+  return [
+    ...constraintIssues,
+    ...value.flatMap((item, index) => validateRepeaterItem(plan, item, index, ctx))
+  ];
 }
-function buildReferenceSchema(field) {
-  let schema = z.string({
-    error: (issue) => issue.input === void 0 || issue.input === null ? "This field is required" : `${field.label} needs text`
+function validateRepeaterItem(plan, item, index, ctx) {
+  if (!isPlainObject(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 = materializeRepeaterItemPlan(childPlan, plan.path, index);
+    return validateNormalizedFieldValue(indexedPlan, item[childPlan.fieldId], ctx);
   });
-  if (field.required) {
-    schema = schema.min(1, { message: `${field.label} is required` });
+}
+function validateGroupPlan(plan, value, ctx) {
+  if (!isPlainObject(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 materializeRepeaterItemPlan(plan, parentPath, index) {
+  return rebaseFieldPlanPath(plan, [...parentPath, 0], [...parentPath, index]);
+}
+function rebaseFieldPlanPath(plan, fromPrefix, toPrefix) {
+  const path21 = rebaseFieldPath(plan.path, fromPrefix, toPrefix);
+  switch (plan.kind) {
+    case "group":
+      return {
+        ...plan,
+        path: path21,
+        children: plan.children.map((childPlan) => rebaseFieldPlanPath(childPlan, fromPrefix, toPrefix))
+      };
+    case "repeater":
+      return {
+        ...plan,
+        path: path21,
+        ...plan.repeatedItemVariants ? {
+          repeatedItemVariants: plan.repeatedItemVariants.map((variant) => ({
+            ...variant,
+            fields: variant.fields.map((fieldPlan) => rebaseFieldPlanPath(fieldPlan, fromPrefix, toPrefix))
+          }))
+        } : {},
+        ...plan.repeatedItemPlan ? {
+          repeatedItemPlan: plan.repeatedItemPlan.map(
+            (fieldPlan) => rebaseFieldPlanPath(fieldPlan, fromPrefix, toPrefix)
+          )
+        } : {}
+      };
+    case "string":
+    case "number":
+    case "boolean":
+    case "richText":
+    case "media":
+    case "link":
+    case "select":
+    case "passthrough":
+      return {
+        ...plan,
+        path: path21
+      };
+    default:
+      return assertNever2(plan);
   }
-  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 rebaseFieldPath(path21, fromPrefix, toPrefix) {
+  if (!startsWithFieldPath(path21, fromPrefix)) {
+    throw new Error(`Cannot rebase field path ${formatFieldPath(path21)} from ${formatFieldPath(fromPrefix)}`);
+  }
+  return [...toPrefix, ...path21.slice(fromPrefix.length)];
+}
+function startsWithFieldPath(path21, prefix) {
+  return prefix.every((segment, index) => path21[index] === segment);
+}
+function issue(plan, kind, extra) {
+  return {
+    kind,
+    path: plan.path,
+    fieldId: plan.fieldId,
+    label: plan.label,
+    ...extra ?? {}
+  };
+}
+function requiredIssue(plan, value) {
+  if (typeof value === "string") return issue(plan, "required", { emptyOrigin: "string" });
+  if (Array.isArray(value)) return issue(plan, "required", { emptyOrigin: "array" });
+  return issue(plan, "required");
+}
+function fieldPlanToZod(plan, options = {}) {
+  const ctx = validationContext(options);
+  return z.any().transform((value) => normalizeFieldValue(plan, value, ctx)).superRefine((value, zodCtx) => {
+    for (const validationIssue of validateNormalizedFieldValue(plan, value, ctx)) {
+      addFieldIssueToZodContext(zodCtx, validationIssue);
     }
+  });
+}
+function addFieldIssueToZodContext(zodCtx, validationIssue) {
+  const message = fieldIssueToMessage(validationIssue);
+  switch (validationIssue.kind) {
+    case "required":
+      if (validationIssue.emptyOrigin) {
+        zodCtx.addIssue({
+          code: "too_small",
+          origin: validationIssue.emptyOrigin,
+          minimum: 1,
+          inclusive: true,
+          message
+        });
+        return;
+      }
+      zodCtx.addIssue({ code: "invalid_type", expected: "nonoptional", message });
+      return;
+    case "tooLong":
+      zodCtx.addIssue({
+        code: "too_big",
+        origin: "string",
+        maximum: validationIssue.maximum,
+        inclusive: true,
+        message
+      });
+      return;
+    case "invalidOption":
+      zodCtx.addIssue({ code: "invalid_value", values: [], message });
+      return;
+    case "wrongType":
+    case "invalidEmail":
+    case "invalidPhone":
+    case "invalidPattern":
+    case "invalidUrl":
+    case "invalidNumber":
+    case "tooSmall":
+    case "tooLarge":
+    case "invalidSlug":
+    case "tooFewItems":
+    case "tooManyItems":
+    case "invalidRichText":
+    case "invalidMedia":
+    case "invalidLink":
+    case "invalidReference":
+      zodCtx.addIssue({ code: "custom", message });
+      return;
+    default:
+      assertNever2(validationIssue);
   }
-  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 compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return null;
   }
-  if (typeof field.maxItems === "number") {
-    arraySchema = arraySchema.max(field.maxItems);
+}
+function isValidNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isValidUrl(value, allowRelative) {
+  if (!value) return false;
+  if (allowRelative && value.startsWith("/")) return true;
+  try {
+    const parsed = new URL(value);
+    return ALLOWED_URL_PROTOCOLS.includes(parsed.protocol);
+  } catch {
+    return false;
   }
-  return arraySchema;
 }
-function buildGroupSchema(field, allowNull, allowIncomplete) {
-  const parsed = fieldSchema.array().parse(field.schema?.fields ?? []);
-  const childShape = {};
-  for (const child of parsed) {
-    childShape[child.id] = buildFieldSchema(child, allowNull, allowIncomplete);
+function isValidSelectValue(value, values, multiple) {
+  if (multiple) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string" && values.includes(item));
   }
-  return z.object(childShape).catchall(z.unknown()).passthrough();
+  return typeof value === "string" && values.includes(value);
 }
-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 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 isPlainObject(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isValidRichTextDoc(value) {
+  const doc = richTextDoc(value);
+  return Boolean(isPlainObject(doc) && doc.type === "doc");
+}
+function isEmptyRichTextDoc(value) {
+  const doc = richTextDoc(value);
+  if (!isPlainObject(doc)) return false;
+  if (doc.type !== "doc") return false;
+  const content = doc.content;
+  if (!Array.isArray(content) || content.length === 0) return true;
+  if (content.length !== 1) return false;
+  const first = content[0];
+  return first?.type === "paragraph" && (!Array.isArray(first.content) || first.content.length === 0);
+}
+function richTextDoc(value) {
+  if (!isPlainObject(value)) return value;
+  return isPlainObject(value.doc) ? value.doc : value;
+}
+
+// ../blocks/src/system/manifest/registry.ts
+var REGISTRY_SYMBOL = /* @__PURE__ */ Symbol.for("@riverbankcms/blocks/manifest-registry");
+var isVitest = typeof process !== "undefined" && typeof process.env !== "undefined" && process.env.VITEST === "true";
+var globalScope = globalThis;
+var manifestStore = isVitest ? /* @__PURE__ */ new Map() : globalScope[REGISTRY_SYMBOL] ??= /* @__PURE__ */ new Map();
+function registerManifest(manifest) {
+  manifestStore.set(manifest.name, manifest);
+  return manifest;
+}
+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 allowNull ? schema.optional().nullable() : schema.optional();
+  return result;
+}
+function createManifestValidator(manifestOrFields, options = {}) {
+  const isDraft = options.mode === "draft";
+  const shape = {};
+  const fields3 = Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? [];
+  for (const field of fields3) {
+    shape[field.id] = buildFieldSchema(field, options);
+  }
+  const baseSchema = z.object(shape).catchall(z.unknown()).passthrough();
+  if (isDraft) {
+    return z.preprocess(preprocessEmptyValues, baseSchema);
+  }
+  return baseSchema;
+}
+function buildFieldSchema(field, options) {
+  return fieldPlanToZod(deriveFieldValidationPlan(field), options);
 }
 
 // ../theme-core/src/site-styles/types.ts
@@ -23465,8 +23706,8 @@ z.discriminatedUnion("kind", [
   }).strict()
 ]);
 function validateBlockSequence(snapshots, ctx) {
-  for (const issue of collectBlockSequenceIssues(snapshots)) {
-    ctx.addIssue(issue);
+  for (const issue2 of collectBlockSequenceIssues(snapshots)) {
+    ctx.addIssue(issue2);
   }
 }
 function collectBlockSequenceIssues(snapshots) {
@@ -24511,7 +24752,7 @@ var sectionStateToneTransform = {
   summary: "Map semantic section-state kind to feedback tone",
   run: (value) => sectionStateToneFromUnknown(value)
 };
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function readString(obj, key) {
@@ -24557,7 +24798,7 @@ var heroContentWrapperClassTransform = {
   summary: "Resolve hero content wrapper className from alignment + max width controls",
   schema: heroContentWrapperClassSchema,
   run: (value, options, context) => {
-    const content = isPlainObject(value) ? value : isPlainObject(context.data) ? context.data : {};
+    const content = isPlainObject2(value) ? value : isPlainObject2(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";
@@ -24576,7 +24817,7 @@ var heroCtaJustifyTransform = {
   kind: "string",
   summary: "Map hero contentAlignment to CTA row justify value",
   run: (value, _options, context) => {
-    const content = isPlainObject(value) ? value : isPlainObject(context.data) ? context.data : {};
+    const content = isPlainObject2(value) ? value : isPlainObject2(context.data) ? context.data : {};
     const alignment = resolveHeroContentAlignment(content);
     return alignment === "left" ? "start" : alignment === "right" ? "end" : "center";
   }
@@ -24586,7 +24827,7 @@ var heroStackJustifyFromVerticalAlignmentTransform = {
   kind: "string",
   summary: "Map hero verticalAlignment to stack justify value",
   run: (value, _options, context) => {
-    const content = isPlainObject(value) ? value : isPlainObject(context.data) ? context.data : {};
+    const content = isPlainObject2(value) ? value : isPlainObject2(context.data) ? context.data : {};
     const vertical = resolveHeroVerticalAlignment(content);
     return vertical === "top" ? "start" : vertical === "bottom" ? "end" : "center";
   }
@@ -24600,7 +24841,7 @@ var heroGridClassFromVerticalAlignmentTransform = {
   summary: "Append align-items class for hero split layouts based on verticalAlignment",
   schema: heroGridClassFromVerticalAlignmentSchema,
   run: (value, options, context) => {
-    const content = isPlainObject(value) ? value : isPlainObject(context.data) ? context.data : {};
+    const content = isPlainObject2(value) ? value : isPlainObject2(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]);
@@ -32015,6 +32256,74 @@ init_shadow2();
 init_blocks();
 init_colorStyles();
 
+// ../api/src/navigation/linkValue.ts
+init_src();
+var Rfc6902PatchOp = z.discriminatedUnion("op", [
+  // Standard RFC-6902 operations
+  z.object({
+    op: z.literal("add"),
+    path: z.string(),
+    value: z.unknown()
+  }),
+  z.object({
+    op: z.literal("remove"),
+    path: z.string()
+  }),
+  z.object({
+    op: z.literal("replace"),
+    path: z.string(),
+    value: z.unknown()
+  }),
+  z.object({
+    op: z.literal("move"),
+    from: z.string(),
+    path: z.string()
+  }),
+  z.object({
+    op: z.literal("copy"),
+    from: z.string(),
+    path: z.string()
+  }),
+  // Block-level operations (Phase 2)
+  z.object({
+    op: z.literal("add_block"),
+    blockKind: z.string(),
+    afterBlockId: z.string().nullable(),
+    content: z.record(z.string(), z.unknown()),
+    rationale: z.string()
+  }),
+  z.object({
+    op: z.literal("delete_block"),
+    blockId: z.string(),
+    rationale: z.string()
+  }),
+  z.object({
+    op: z.literal("reorder_block"),
+    blockId: z.string(),
+    afterBlockId: z.string().nullable(),
+    rationale: z.string()
+  })
+]);
+z.object({
+  request: z.string().min(1).max(2e3)
+});
+var MultiPagePatchEnvelope = z.object({
+  pageId: z.string(),
+  blockId: z.string().optional(),
+  // Not present for page-level ops
+  blockKind: z.string().optional(),
+  blockPurpose: z.string().optional().nullable(),
+  ops: z.array(Rfc6902PatchOp),
+  rationale: z.string(),
+  currentContent: z.record(z.string(), z.unknown()).optional()
+});
+z.object({
+  patches: z.array(MultiPagePatchEnvelope),
+  assistantMessage: z.string(),
+  pagesModified: z.number(),
+  toolCallsUsed: z.number()
+});
+
 // src/types/block-kinds.ts
 var SYSTEM_BLOCK_KINDS = [
   // Layout blocks
@@ -32242,7 +32551,7 @@ var fieldBindingSchema = z.object({
 var metaBindingSchema = z.object({
   source: z.literal("meta"),
   path: z.enum(TEMPLATE_BINDING_META_PATHS, {
-    error: (issue) => describeInvalidTemplateBindingMetaPath(String(issue.input))
+    error: (issue2) => describeInvalidTemplateBindingMetaPath(String(issue2.input))
   })
 });
 var literalBindingSchema = z.object({
@@ -32253,7 +32562,7 @@ var transformBindingSchema = z.object({
   source: z.literal("transform"),
   path: z.string().min(1, "Transform path is required"),
   transform: z.enum(BINDING_TRANSFORM_VALUES, {
-    error: (issue) => describeInvalidBindingTransform(String(issue.input))
+    error: (issue2) => describeInvalidBindingTransform(String(issue2.input))
   })
 });
 var baseBindingSchema = z.discriminatedUnion("source", [
@@ -34659,9 +34968,9 @@ async function pushConfigAction(output, options) {
     const parseResult = riverbankSiteConfigSchema.safeParse(rawConfig);
     if (!parseResult.success) {
       output.error("Invalid config", {
-        issues: parseResult.error.issues.map((issue) => ({
-          path: issue.path.join("."),
-          message: issue.message
+        issues: parseResult.error.issues.map((issue2) => ({
+          path: issue2.path.join("."),
+          message: issue2.message
         }))
       });
     }
@@ -35595,7 +35904,7 @@ async function readSettings(contentDir) {
   if (!parsed.success) {
     throw new Error(
       `${filePath}: invalid settings.json
-` + parsed.error.issues.map((issue) => `  - ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n")
+` + parsed.error.issues.map((issue2) => `  - ${issue2.path.join(".") || "(root)"}: ${issue2.message}`).join("\n")
     );
   }
   return parsed.data;
@@ -38436,15 +38745,15 @@ function validateBlockContent(data, manifest, customFields) {
     validator.parse(data);
   } catch (error) {
     if (error instanceof ZodError) {
-      for (const issue of error.issues) {
-        const fieldPath = issue.path.join(".");
-        if (issue.code === "invalid_type" && issue.received === "undefined") {
+      for (const issue2 of error.issues) {
+        const fieldPath = issue2.path.join(".");
+        if (issue2.code === "invalid_type" && issue2.received === "undefined") {
           continue;
         }
         warnings.push({
           type: "invalid_content",
           field: fieldPath || "(root)",
-          message: `Invalid content${fieldPath ? ` in "${fieldPath}"` : ""}: ${issue.message}`
+          message: `Invalid content${fieldPath ? ` in "${fieldPath}"` : ""}: ${issue2.message}`
         });
       }
     }
@@ -41309,7 +41618,7 @@ async function handleThemePushForAllScope(params) {
   }
   const validation = themeSchema2.safeParse(localTheme.theme);
   if (!validation.success) {
-    const errors = validation.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+    const errors = validation.error.issues.map((issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`).join("\n");
     output.warn(
       `Skipping theme push - invalid theme at content/themes/${themeName}.json:
 ${errors}`
@@ -42022,7 +42331,7 @@ ${available.map((t) => `  - ${t.name} (content/themes/${t.name}.json)`).join("\n
       }
       const validation = themeSchema.safeParse(localTheme.theme);
       if (!validation.success) {
-        const errors = validation.error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+        const errors = validation.error.issues.map((issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`).join("\n");
         output.error(
           `Invalid theme file at content/themes/${themeName}.json:
 ${errors}`
@@ -45110,7 +45419,7 @@ var SimpleCache = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "0.60.7";
+var SDK_VERSION = "0.60.11";
 
 // src/client/error.ts
 var RiverbankApiError = class _RiverbankApiError extends Error {
@@ -46913,9 +47222,9 @@ Examples:
     const parseResult = verifyConfigSchema.safeParse(rawConfig);
     if (!parseResult.success) {
       return output.error("Invalid config format", {
-        issues: parseResult.error.issues.map((issue) => ({
-          path: issue.path.join("."),
-          message: issue.message
+        issues: parseResult.error.issues.map((issue2) => ({
+          path: issue2.path.join("."),
+          message: issue2.message
         })),
         suggestion: "Ensure your config exports a valid riverbank config object"
       });
@@ -47443,8 +47752,8 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
         client
       });
       const mediaIssues = mapMediaGuardDiagnosticsToAuditIssues(mediaGuardResult.diagnostics);
-      errors.push(...mediaIssues.filter((issue) => issue.severity === "error"));
-      warnings.push(...mediaIssues.filter((issue) => issue.severity === "warning"));
+      errors.push(...mediaIssues.filter((issue2) => issue2.severity === "error"));
+      warnings.push(...mediaIssues.filter((issue2) => issue2.severity === "warning"));
     }
     if (!isJsonOutput) {
       output.info("Checking for duplicate page paths...");
@@ -47468,8 +47777,8 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
     }
     errors.push(...auditEventReferences(localContent.events, auditCtx));
     const courseRefIssues = auditCourseReferences(localContent.courses, auditCtx);
-    errors.push(...courseRefIssues.filter((issue) => issue.severity === "error"));
-    warnings.push(...courseRefIssues.filter((issue) => issue.severity === "warning"));
+    errors.push(...courseRefIssues.filter((issue2) => issue2.severity === "error"));
+    warnings.push(...courseRefIssues.filter((issue2) => issue2.severity === "warning"));
     const success = errors.length === 0;
     const result = { success, errors, warnings };
     if (isJsonOutput) {
@@ -47484,14 +47793,14 @@ async function executeAuditForEnv(output, target, options, isJsonOutput) {
       output.info("");
       if (errors.length > 0) {
         output.warn(`Found ${errors.length} error(s):`);
-        for (const issue of errors) {
-          output.info(`  [ERROR] ${issue.message}`);
+        for (const issue2 of errors) {
+          output.info(`  [ERROR] ${issue2.message}`);
         }
       }
       if (warnings.length > 0) {
         output.warn(`Found ${warnings.length} warning(s):`);
-        for (const issue of warnings) {
-          output.info(`  [WARN] ${issue.message}`);
+        for (const issue2 of warnings) {
+          output.info(`  [WARN] ${issue2.message}`);
         }
       }
       if (success && warnings.length === 0) {
@@ -51523,7 +51832,7 @@ Examples:
   $ riverbankcms course delete beginner-yoga --yes
 `
 ).addCommand(listCommand7).addCommand(getCommand6).addCommand(upsertCommand6).addCommand(cancelCommand2).addCommand(deleteCommand3);
-function isPlainObject2(value) {
+function isPlainObject3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function migrateLegacyEntryTitleInPlace(entry) {
@@ -51531,7 +51840,7 @@ function migrateLegacyEntryTitleInPlace(entry) {
   const titleValue = entry.title;
   delete entry.title;
   let migratedToDataTitle = false;
-  if (typeof titleValue === "string" && isPlainObject2(entry.data)) {
+  if (typeof titleValue === "string" && isPlainObject3(entry.data)) {
     const data = entry.data;
     if (!("title" in data)) {
       data.title = titleValue;
@@ -51557,7 +51866,7 @@ async function backupLegacyFile(contentDir, legacyFilePath, dryRun) {
 }
 async function migrateLegacyEntriesFile(contentDir, legacyFilePath, options) {
   const raw = await readJsonFile(legacyFilePath);
-  if (!isPlainObject2(raw)) {
+  if (!isPlainObject3(raw)) {
     throw new Error(`Legacy entries file is not an object: ${legacyFilePath}`);
   }
   const contentType = raw.contentType;
@@ -51578,14 +51887,14 @@ async function migrateLegacyEntriesFile(contentDir, legacyFilePath, options) {
   let legacyTitlesMigrated = 0;
   let legacyTitleFilesUpdated = 0;
   for (const entryUnknown of entries) {
-    if (!isPlainObject2(entryUnknown)) {
+    if (!isPlainObject3(entryUnknown)) {
       throw new Error(`Invalid legacy entry (expected object): ${legacyFilePath}`);
     }
     const identifier = entryUnknown.identifier;
     if (typeof identifier !== "string" || identifier.length === 0) {
       throw new Error(`Invalid legacy entry identifier in: ${legacyFilePath}`);
     }
-    if (!isPlainObject2(entryUnknown.data)) {
+    if (!isPlainObject3(entryUnknown.data)) {
       throw new Error(`Invalid legacy entry data (expected object) for "${identifier}" in: ${legacyFilePath}`);
     }
     const { updated, migratedToDataTitle } = migrateLegacyEntryTitleInPlace(entryUnknown);
@@ -51620,7 +51929,7 @@ async function migrateLegacyTitlesInDirectory(typeDir, options) {
   for (const filePath of files) {
     scanned += 1;
     const raw = await readJsonFile(filePath);
-    if (!isPlainObject2(raw)) continue;
+    if (!isPlainObject3(raw)) continue;
     const { updated, migratedToDataTitle } = migrateLegacyEntryTitleInPlace(raw);
     if (!updated) continue;
     updatedFiles += 1;