@riverbankcms/sdk 0.132.0 → 0.134.0

package/dist/client/bookings.mjs

@@ -3211,20 +3211,7 @@ function createBlockApi(config) {
 			const path = buildPath(WHOLE_SERIES.checkout.path, { siteId: sid });
 			return request(WHOLE_SERIES.checkout, {
 				path,
-				body: {
-					eventSeriesId: data.eventSeriesId,
-					...data.pricingOptionId ? { pricingOptionId: data.pricingOptionId } : {},
-					...data.selectedSlidingAmount !== void 0 ? { selectedSlidingAmount: data.selectedSlidingAmount } : {},
-					email: data.email,
-					name: data.name,
-					phone: data.phone,
-					formData: data.formData,
-					altchaSolution: data.altchaSolution,
-					discountCode: data.discountCode,
-					successUrl: data.successUrl,
-					cancelUrl: data.cancelUrl,
-					claimToken: data.claimToken
-				}
+				body: data
 			});
 		},
 		async getWholeSeriesRegistrationStatus(params) {
@@ -3676,7 +3663,7 @@ function getChallengeUrl() {
 }
 //#endregion
 //#region ../core/src/result.ts
-function ok(value) {
+function ok$1(value) {
 	return {
 		ok: true,
 		value
@@ -3696,11 +3683,14 @@ function parseUuidBrand(value, unsafeConstructor) {
 	const normalized = value.trim().toLowerCase();
 	if (normalized.length === 0) return err$1({ kind: "empty_string" });
 	if (!UUID_PATTERN.test(normalized)) return err$1({ kind: "invalid_uuid" });
-	return ok(unsafeConstructor(normalized));
+	return ok$1(unsafeConstructor(normalized));
 }
 const unsafeAsSiteId = (id) => id;
 const unsafeAsEventOfferingId = (id) => id;
 const unsafeAsEventSeriesId = (id) => id;
+const unsafeAsMediaAssetId = (id) => id;
+const unsafeAsStorageBucketName = (value) => value;
+const unsafeAsStoragePath = (value) => value;
 const unsafeAsFormId = (id) => id;
 const unsafeAsPassId = (id) => id;
 const unsafeAsCustomerPassId = (id) => id;
@@ -3843,7 +3833,7 @@ function parseEventPageSurfaceSubject(value) {
 				kind: "invalidEventSeriesBookingScope",
 				bookingScope: value.bookingScope
 			});
-			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
+			return ok$1(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
 		}
 		case "eventOffering": {
 			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
@@ -3864,7 +3854,7 @@ function parseEventPageSurfaceSubject(value) {
 				});
 				parsedSeriesIds.push(eventSeriesId.value);
 			}
-			return ok({
+			return ok$1({
 				kind: "eventOffering",
 				eventOfferingId: eventOfferingId.value,
 				availableEventSeriesIds: parsedSeriesIds
@@ -3982,7 +3972,7 @@ function parseBookingTimeZone(timeZone) {
 	if (typeof timeZone !== "string") return err$1("invalid-time-zone");
 	const normalized = timeZone.trim();
 	if (normalized.length === 0 || NUMERIC_OFFSET_TIME_ZONE_PATTERN.test(normalized) || !isValidBookingTimeZone(normalized)) return err$1("invalid-time-zone");
-	return ok(normalized);
+	return ok$1(normalized);
 }
 //#endregion
 //#region ../core/src/booking-date-time.ts
@@ -4061,7 +4051,7 @@ function parseUtcIsoDateTimeString(value) {
 	if (!hasUtcSuffix && !hasExplicitOffset) return err$1("missing-timezone-offset");
 	const date = new Date(normalized);
 	if (Number.isNaN(date.getTime())) return err$1("invalid-date-time");
-	return ok(date.toISOString());
+	return ok$1(date.toISOString());
 }
 function toUtcIsoDateTimeString(value) {
 	const parsed = parseUtcIsoDateTimeString(value);
@@ -4213,6 +4203,109 @@ function assertNever(value, message) {
 	throw new Error(message ?? `Unexpected value: ${String(value)}`);
 }
 //#endregion
+//#region ../blocks/src/system/manifest/richTextSchema.ts
+/**
+* Shared Rich Text Schema
+*
+* This module provides a single source of truth for TipTap rich text validation
+* across both the block-form editor and the block rendering system.
+*
+* Rich-text fields use one canonical root shape:
+* `{ type: 'doc', content: [...] }`.
+*/
+/**
+* TipTap document node schema (recursive structure)
+*
+* Supports the full TipTap document structure including:
+* - type: Node type (e.g., 'doc', 'paragraph', 'text')
+* - content: Nested array of child nodes
+* - text: Text content for text nodes
+* - attrs: Node attributes (e.g., alignment, color)
+* - marks: Text formatting marks (e.g., bold, italic)
+*/
+const TipTapMarkSchema = z.object({
+	type: z.string().min(1),
+	attrs: z.record(z.string(), z.unknown()).optional()
+}).strict();
+const TipTapNodeSchema = z.lazy(() => z.object({
+	type: z.string().min(1),
+	content: z.array(TipTapNodeSchema).optional(),
+	text: z.string().optional(),
+	attrs: z.record(z.string(), z.unknown()).optional(),
+	marks: z.array(TipTapMarkSchema).optional()
+}).strict().superRefine((node, ctx) => {
+	if (node.type === "doc") ctx.addIssue({
+		code: "custom",
+		path: ["type"],
+		message: "Document nodes are only valid at the rich-text root"
+	});
+	if (node.type === "text") {
+		if (node.text === void 0 || node.text.length === 0) ctx.addIssue({
+			code: "custom",
+			path: ["text"],
+			message: "Text nodes require a non-empty text value"
+		});
+		if (node.content !== void 0) ctx.addIssue({
+			code: "custom",
+			path: ["content"],
+			message: "Text nodes cannot contain child nodes"
+		});
+		return;
+	}
+	if (node.text !== void 0) ctx.addIssue({
+		code: "custom",
+		path: ["text"],
+		message: "Only text nodes can contain a text value"
+	});
+}));
+/**
+* Canonical schema for a TipTap rich-text document root.
+*
+* Stricter than {@link TipTapNodeSchema}: `type` is literally `'doc'` and
+* `content` is required (possibly empty). This is the shape every producer
+* (dummy content, editor output, migrations) must emit, and the shape every
+* non-legacy consumer can rely on.
+*
+*/
+const RichTextDocSchema = z.object({
+	type: z.literal("doc"),
+	content: z.array(TipTapNodeSchema)
+}).strict();
+//#endregion
+//#region ../blocks/src/system/blocks/shared/bookingConsent.ts
+const BOOKING_REQUIREMENT_CONSENT_FIELD_PREFIX = "booking_requirement_consent_";
+function toBookingRequirementConsentFieldId(requirementId) {
+	return `${BOOKING_REQUIREMENT_CONSENT_FIELD_PREFIX}${requirementId}`;
+}
+function isBookingRequirementConsentFieldId(value) {
+	return value.startsWith(BOOKING_REQUIREMENT_CONSENT_FIELD_PREFIX);
+}
+function toBookingRequirementConsentField(consent) {
+	return {
+		id: toBookingRequirementConsentFieldId(consent.requirementId),
+		label: consent.title,
+		type: "booking_requirement_consent",
+		required: true,
+		agreement: consent.agreement,
+		checkboxLabel: consent.checkboxLabel
+	};
+}
+const blockBookingConsentSchema = z.object({
+	requirementId: z.string(),
+	title: z.string(),
+	agreement: RichTextDocSchema,
+	checkboxLabel: z.string()
+});
+const bookingRequirementConsentFieldSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	type: z.literal("booking_requirement_consent"),
+	required: z.literal(true),
+	agreement: RichTextDocSchema,
+	checkboxLabel: z.string().min(1)
+});
+z.union([blockBookingConsentSchema, bookingRequirementConsentFieldSchema]);
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.reserved-fields.ts
 const BOOKING_FORM_DATA_RESERVED_KEY_VALUES = [
 	"serviceId",
@@ -4226,6 +4319,28 @@ const BOOKING_FORM_DATA_RESERVED_KEY_VALUES = [
 ];
 const BOOKING_FORM_DATA_RESERVED_KEYS = new Set(BOOKING_FORM_DATA_RESERVED_KEY_VALUES);
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/booking-form.consent.ts
+function resolveSelectedAppointmentConsent(service) {
+	return service?.consent ? {
+		kind: "required-for-selected-service",
+		field: toBookingRequirementConsentField(service.consent)
+	} : { kind: "not-applicable" };
+}
+function projectSelectedAppointmentConsentIntoForm(form, selectedConsent) {
+	if (!form) return null;
+	const sourceFields = form.schema?.fields ?? [];
+	const baseFields = sourceFields.filter((field) => field.type !== "booking_requirement_consent");
+	const fields = selectedConsent.kind === "required-for-selected-service" ? [...baseFields, selectedConsent.field] : baseFields;
+	if (selectedConsent.kind === "not-applicable" && baseFields.length === sourceFields.length) return form;
+	return {
+		...form,
+		schema: {
+			...form.schema,
+			fields
+		}
+	};
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.state.ts
 function toTrimmedString(value) {
 	const trimmed = value?.trim();
@@ -4408,7 +4523,6 @@ function readBookingFieldType(value) {
 		case "select":
 		case "radio":
 		case "checkbox":
-		case "booking_requirement_consent":
 		case "tel":
 		case "url":
 		case "number":
@@ -4443,7 +4557,7 @@ function normalizeBookingSettings(value) {
 	};
 }
 function isBookingFormService(value) {
-	return isRecord$5(value) && typeof value.id === "string" && typeof value.siteId === "string" && typeof value.title === "string";
+	return isRecord$5(value) && typeof value.id === "string" && typeof value.siteId === "string" && typeof value.title === "string" && (value.consent === void 0 || blockBookingConsentSchema.safeParse(value.consent).success);
 }
 function collectBookingCustomFields(data) {
 	const customFields = {};
@@ -4687,6 +4801,11 @@ function getBookingSuccessMessage(successMessage) {
 	return successMessage?.trim() || "Your appointment has been booked! Check your email for confirmation.";
 }
 //#endregion
+//#region ../blocks/src/system/runtime/hooks/useSelectedAppointmentConsentForm.ts
+function useSelectedAppointmentConsentForm(form, selectedService) {
+	return useMemo(() => projectSelectedAppointmentConsentIntoForm(form, resolveSelectedAppointmentConsent(selectedService)), [form, selectedService]);
+}
+//#endregion
 //#region ../blocks/src/utils/date-formatting.ts
 /**
 * Resolve the browser/runtime timezone for booking surfaces.
@@ -5751,6 +5870,19 @@ function clearBookingFieldError(errors, fieldId) {
 	};
 }
 //#endregion
+//#region ../blocks/src/system/runtime/nodes/booking-form.field-values.ts
+function collectInitialBookingFieldValues(initialData) {
+	const values = {};
+	for (const [key, value] of Object.entries(initialData)) if (!BOOKING_FORM_DATA_RESERVED_KEYS.has(key) && !isBookingRequirementConsentFieldId(key) && isBookingFieldValue(value)) values[key] = value;
+	return values;
+}
+function omitBookingConsentEntries(record) {
+	return Object.fromEntries(Object.entries(record).filter(([key]) => !isBookingRequirementConsentFieldId(key)));
+}
+function isBookingFieldValue(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.headless.state.ts
 const unsafeAsBookingFieldId = (id) => id;
 function createInitialBookingFlowReducerState(input) {
@@ -5762,7 +5894,7 @@ function createInitialBookingFlowReducerState(input) {
 		selectedResourceId: toOptionalAppointmentResourceId(toOptionalString(initialData.resourceId) ?? input.defaultResourceId),
 		selectedDate: toOptionalString(initialData.selectedDate),
 		selectedSlot: null,
-		fieldValues: collectInitialFieldValues(initialData),
+		fieldValues: collectInitialBookingFieldValues(initialData),
 		touchedFields: {},
 		attemptedStepIds: {},
 		discountCode: toOptionalString(initialData.discountCode) ?? "",
@@ -5774,14 +5906,6 @@ function createInitialBookingFlowReducerState(input) {
 		feedback: { kind: "none" }
 	};
 }
-function collectInitialFieldValues(initialData) {
-	const values = {};
-	for (const [key, value] of Object.entries(initialData)) {
-		if (BOOKING_FORM_DATA_RESERVED_KEYS.has(key) || !isBookingFieldValue(value)) continue;
-		values[key] = value;
-	}
-	return values;
-}
 function toOptionalString(value) {
 	if (typeof value !== "string") return void 0;
 	const trimmed = value.trim();
@@ -5803,9 +5927,6 @@ function toOptionalAppointmentResourceId(value) {
 function toOptionalCustomerPassId(value) {
 	return toOptionalBrandedId(value, unsafeAsCustomerPassId);
 }
-function isBookingFieldValue(value) {
-	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every((item) => typeof item === "string");
-}
 /**
 * Send the flow back to the date step when the slot it was holding went away,
 * leaving a scoped feedback message. A completed booking is left alone.
@@ -5827,17 +5948,7 @@ function applyAvailabilitySelectionInvalidation(state, invalidation) {
 }
 function bookingFlowReducer(state, event) {
 	switch (event.type) {
-		case "service-selected": return {
-			...state,
-			selectedServiceId: event.serviceId,
-			selectedResourceId: void 0,
-			selectedDate: void 0,
-			selectedSlot: null,
-			selectedAppointmentPackageId: void 0,
-			selectedSlidingAmountInput: "",
-			selectedCollectionOptionKind: void 0,
-			validationErrors: clearBookingFormError(state.validationErrors)
-		};
+		case "service-selected": return applyBookingServiceSelection(state, event.serviceId);
 		case "resource-selected": return {
 			...state,
 			selectedResourceId: event.resourceId ?? void 0,
@@ -5944,6 +6055,24 @@ function bookingFlowReducer(state, event) {
 		default: return assertNever(event);
 	}
 }
+function applyBookingServiceSelection(state, serviceId) {
+	return {
+		...state,
+		selectedServiceId: serviceId,
+		selectedResourceId: void 0,
+		selectedDate: void 0,
+		selectedSlot: null,
+		selectedAppointmentPackageId: void 0,
+		selectedSlidingAmountInput: "",
+		selectedCollectionOptionKind: void 0,
+		fieldValues: omitBookingConsentEntries(state.fieldValues),
+		touchedFields: omitBookingConsentEntries(state.touchedFields),
+		validationErrors: {
+			...clearBookingFormError(state.validationErrors),
+			fieldErrors: omitBookingConsentEntries(state.validationErrors.fieldErrors)
+		}
+	};
+}
 function clearAvailabilityFeedback(feedback) {
 	return feedback.kind === "error" && feedback.scope === "availability" ? { kind: "none" } : feedback;
 }
@@ -6104,7 +6233,8 @@ function validateBookingFields(input) {
 	return errors;
 }
 function validateBookingField(field, value) {
-	if (field.required && isBlankFieldValue(value)) return `${field.label} is required`;
+	const requiredError = validateRequiredBookingField(field, value);
+	if (requiredError) return requiredError;
 	if (isBlankFieldValue(value)) return null;
 	const strValue = typeof value === "string" ? value : String(value);
 	if (field.type === "email") return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(strValue) ? null : "Please enter a valid email address";
@@ -6133,6 +6263,10 @@ function validateBookingField(field, value) {
 	}
 	return null;
 }
+function validateRequiredBookingField(field, value) {
+	if (field.type === "booking_requirement_consent") return value === true ? null : `${field.label} is required`;
+	return field.required && isBlankFieldValue(value) ? `${field.label} is required` : null;
+}
 function deriveBookingFlowSteps(input) {
 	const stepResolution = buildBookingStepResolution({
 		form: input.form,
@@ -6204,7 +6338,8 @@ function deriveBookingFieldViews(input) {
 	return (input.form?.schema?.fields ?? []).map((field) => {
 		const fieldId = unsafeAsBookingFieldId(field.id);
 		const inputId = `${input.idPrefix}-${fieldId}`;
-		const helpTextId = field.helpText ? `${inputId}-help` : null;
+		const helpText = field.type === "booking_requirement_consent" ? null : field.helpText ?? null;
+		const helpTextId = helpText ? `${inputId}-help` : null;
 		const fieldValue = input.values[field.id] ?? null;
 		const localError = input.touched?.[field.id] ? validateBookingField(field, fieldValue) : null;
 		const error = input.errors[field.id] ?? localError;
@@ -6214,17 +6349,17 @@ function deriveBookingFieldViews(input) {
 			field,
 			id: fieldId,
 			label: field.label,
-			type: field.type,
 			value: fieldValue,
 			required: Boolean(field.required),
 			error,
-			helpText: field.helpText ?? null,
+			helpText,
 			inputId,
 			labelId: `${inputId}-label`,
 			helpTextId,
 			errorId,
 			describedBy,
-			ariaInvalid: Boolean(error)
+			ariaInvalid: Boolean(error),
+			type: field.type
 		};
 	});
 }
@@ -6486,6 +6621,7 @@ function useHeadlessBookingFlow(options) {
 	const selectedServiceId = state.selectedServiceId ?? defaultServiceId;
 	const selectedResourceId = state.selectedResourceId ?? defaultResourceId;
 	const selectedService = options.services.find((service) => service.id === selectedServiceId) ?? null;
+	const runtimeForm = useSelectedAppointmentConsentForm(options.form, selectedService);
 	const lastSlidingServiceIdRef = useRef(null);
 	useEffect(() => {
 		const selectedId = selectedService?.id ?? null;
@@ -6526,7 +6662,7 @@ function useHeadlessBookingFlow(options) {
 		viewerTimeZone
 	]);
 	const stepState = useMemo(() => deriveBookingFlowSteps({
-		form: options.form,
+		form: runtimeForm,
 		services: options.services,
 		data,
 		defaultServiceId,
@@ -6542,7 +6678,7 @@ function useHeadlessBookingFlow(options) {
 		defaultServiceId,
 		defaultResourceId,
 		options.enableAppointmentPackages,
-		options.form,
+		runtimeForm,
 		options.requiresResourceSelection,
 		options.requiresServiceSelection,
 		options.services,
@@ -6596,13 +6732,13 @@ function useHeadlessBookingFlow(options) {
 		state.selectedSlot
 	]);
 	const fields = useMemo(() => deriveBookingFieldViews({
-		form: options.form,
+		form: runtimeForm,
 		values: state.fieldValues,
 		errors: state.validationErrors.fieldErrors,
 		touched: state.touchedFields,
 		idPrefix: `booking-${options.formId}`
 	}), [
-		options.form,
+		runtimeForm,
 		options.formId,
 		state.fieldValues,
 		state.touchedFields,
@@ -6722,7 +6858,7 @@ function useHeadlessBookingFlow(options) {
 	const latestRef = useLatestRef({
 		state,
 		data,
-		form: options.form,
+		form: runtimeForm,
 		formId: formKey,
 		services: options.services,
 		defaultServiceId,
@@ -6974,7 +7110,7 @@ function useHeadlessBookingFlow(options) {
 		phase: state.phase
 	});
 	const view = resolveHeadlessBookingView({
-		form: options.form,
+		form: runtimeForm,
 		feedback: state.feedback
 	});
 	const appointmentPackagesModel = resolveAppointmentPackagesModel({
@@ -12416,6 +12552,768 @@ function FieldValidationMessage({ id, children, className, live = "assertive" })
 	});
 }
 //#endregion
+//#region ../blocks/src/primitives/content/utils/sanitizeHref.ts
+const SAFE_PROTOCOLS = /* @__PURE__ */ new Set([
+	"http:",
+	"https:",
+	"mailto:",
+	"tel:"
+]);
+const CONTROL_CHARS_PATTERN = /[\u0000-\u001F\u007F]+/g;
+function normalizeInput(value) {
+	return value.replace(CONTROL_CHARS_PATTERN, "").trim();
+}
+function decodeForSchemeCheck(value) {
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+}
+/**
+* Returns a safe href for rich-text anchors, or null when the value should not be rendered.
+*
+* Policy:
+* - Allow absolute URLs with protocols: http, https, mailto, tel.
+* - Allow root-relative ("/path") and hash-only ("#section") links.
+* - Reject protocol-relative URLs ("//example.com"), bare domains ("example.com"),
+*   executable schemes (javascript/data/vbscript), malformed URLs, and empty values.
+* - Preserve percent-encoding from the original normalized input.
+*/
+function sanitizeHref(raw) {
+	if (typeof raw !== "string") return null;
+	const normalized = normalizeInput(raw);
+	if (!normalized) return null;
+	if (normalized.startsWith("//")) return null;
+	if (normalized.startsWith("/")) return normalized;
+	if (normalized.startsWith("#")) return normalized;
+	const schemeMatch = normalizeInput(decodeForSchemeCheck(normalized)).match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/);
+	if (!schemeMatch) return null;
+	const rawScheme = schemeMatch[1];
+	if (!rawScheme) return null;
+	const protocol = `${rawScheme.toLowerCase()}:`;
+	if (!SAFE_PROTOCOLS.has(protocol)) return null;
+	try {
+		const parsed = new URL(normalized);
+		if (!SAFE_PROTOCOLS.has(parsed.protocol.toLowerCase())) return null;
+	} catch {
+		return null;
+	}
+	return normalized;
+}
+//#endregion
+//#region ../media-core/src/fileSafety.ts
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/u;
+function containsUnsafePathSegmentCharacter(value) {
+	return value.includes("/") || value.includes("\\") || CONTROL_CHARACTER_PATTERN.test(value);
+}
+function isReservedPathSegment(value) {
+	return value === "." || value === "..";
+}
+function isUnsafePathSegment(segment) {
+	return segment.trim().length === 0 || segment !== segment.trim() || isReservedPathSegment(segment) || containsUnsafePathSegmentCharacter(segment);
+}
+({
+	publicSite: unsafeAsStorageBucketName("media"),
+	privateSite: unsafeAsStorageBucketName("site-files-private"),
+	temporary: unsafeAsStorageBucketName("temp-uploads")
+}).publicSite;
+function parseStoragePath(value) {
+	return joinStoragePathSegments(value.split("/"));
+}
+/**
+* Joins already-branded path segments while preserving the Storage RLS invariant
+* that every tenant/site identifier remains one segment, never a nested path.
+*/
+function joinStoragePathSegments(segments) {
+	if (segments.some(isUnsafePathSegment)) return err$1("unsafe-path-segment");
+	return ok$1(unsafeAsStoragePath(segments.join("/")));
+}
+//#endregion
+//#region ../media-core/src/storagePathDomain.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function fail(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+function normalizeStringInput(value) {
+	if (typeof value !== "string") return fail({ tag: "MISSING" });
+	const trimmed = value.trim();
+	if (!trimmed) return fail({ tag: "EMPTY" });
+	return ok(trimmed);
+}
+function validateRelativeStoragePath(value) {
+	if (value.startsWith("sites/")) return fail({ tag: "SITE_SCOPED_PATH" });
+	if (value.startsWith("/")) return fail({ tag: "LEADING_SLASH" });
+	if (value.includes("//")) return fail({ tag: "DOUBLE_SLASH" });
+	if (value.includes("%")) return fail({ tag: "PERCENT_ENCODING" });
+	if (value.split("/").some((segment) => segment === "." || segment === "..")) return fail({ tag: "TRAVERSAL" });
+	return ok(value);
+}
+function brandRelativeStoragePath(value) {
+	return value;
+}
+function parseRelativeStoragePath(value) {
+	const normalized = normalizeStringInput(value);
+	if (!normalized.ok) return normalized;
+	const validated = validateRelativeStoragePath(normalized.value);
+	if (!validated.ok) return validated;
+	return ok(brandRelativeStoragePath(validated.value));
+}
+//#endregion
+//#region ../media-core/src/url.ts
+const DEFAULT_BASE_PATH = "/api/img";
+function isSiteScopedDirectImageStoragePath(storagePath) {
+	return storagePath.startsWith("sites/") && parseStoragePath(storagePath).ok;
+}
+function encodeStoragePath(storagePath) {
+	return storagePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function resolveDirectImagePathTarget(target) {
+	switch (target.kind) {
+		case "relative": return `sites/${target.siteId}/${target.storagePath}`;
+		case "site-scoped":
+		case "bucket-scoped": return target.storagePath;
+	}
+}
+function getDirectImageUrl(supabaseUrl, target, storageBucket = "media", options) {
+	const baseUrl = supabaseUrl.replace(/\/$/, "");
+	const encodedPath = encodeStoragePath(resolveDirectImagePathTarget(target));
+	const isSvg = target.storagePath.toLowerCase().endsWith(".svg");
+	if (options && !isSvg && (options.width || options.height)) {
+		const params = new URLSearchParams();
+		if (options.width) params.set("width", String(options.width));
+		if (options.height) params.set("height", String(options.height));
+		if (options.quality) params.set("quality", String(options.quality));
+		if (options.resize) params.set("resize", options.resize);
+		return `${baseUrl}/storage/v1/render/image/public/${storageBucket}/${encodedPath}?${params.toString()}`;
+	}
+	return `${baseUrl}/storage/v1/object/public/${storageBucket}/${encodedPath}`;
+}
+function getDirectImageUrlForRelativePath(supabaseUrl, storagePath, siteId, storageBucket = "media", options) {
+	return getDirectImageUrl(supabaseUrl, {
+		kind: "relative",
+		storagePath,
+		siteId
+	}, storageBucket, options);
+}
+function getDirectImageUrlForSiteScopedPath(supabaseUrl, storagePath, storageBucket = "media", options) {
+	return getDirectImageUrl(supabaseUrl, {
+		kind: "site-scoped",
+		storagePath
+	}, storageBucket, options);
+}
+const formatNumber = (value) => Number.isInteger(value) ? value.toString() : value.toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+const ORDER = [
+	"w",
+	"h",
+	"fit",
+	"rect",
+	"q",
+	"autoFormat",
+	"or"
+];
+const getImageUrl = (asset, params = {}, basePath = DEFAULT_BASE_PATH) => {
+	const path = `${basePath.endsWith("/") ? basePath.slice(0, Math.max(basePath.length - 1, 0)) : basePath}/${encodeURIComponent(asset.id)}`;
+	const searchParams = new URLSearchParams();
+	if (params.w !== void 0) searchParams.set("w", formatNumber(params.w));
+	if (params.h !== void 0) searchParams.set("h", formatNumber(params.h));
+	if (params.fit !== void 0) searchParams.set("fit", params.fit);
+	if (params.rect) searchParams.set("rect", params.rect.map(formatNumber).join(","));
+	if (params.q !== void 0) searchParams.set("q", formatNumber(params.q));
+	if (params.autoFormat) searchParams.append("auto", "format");
+	if (params.or !== void 0) searchParams.set("or", String(params.or));
+	const sorted = new URLSearchParams();
+	ORDER.forEach((key) => {
+		if (key === "autoFormat") {
+			if (params.autoFormat) sorted.append("auto", "format");
+			return;
+		}
+		const value = searchParams.get(key);
+		if (value !== null) sorted.set(key, value);
+	});
+	const query = sorted.toString();
+	return query ? `${path}?${query}` : path;
+};
+//#endregion
+//#region ../media-core/src/transformRect.ts
+function isValidTransformRectStructure(rect) {
+	if (!Array.isArray(rect) || rect.length !== 4) return false;
+	const [left, top, width, height] = rect;
+	return Number.isFinite(left) && Number.isFinite(top) && Number.isFinite(width) && Number.isFinite(height) && left >= 0 && top >= 0 && width > 0 && height > 0;
+}
+//#endregion
+//#region ../media-core/src/aspectTransforms.ts
+const DEFAULT_RECT_EPSILON = .5;
+function parseAspectRatioValue(value) {
+	if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : void 0;
+	if (typeof value !== "string") return void 0;
+	const normalized = value.trim();
+	if (!normalized) return void 0;
+	if (normalized === "auto") return void 0;
+	if (normalized.includes(":") || normalized.includes("/")) {
+		const delimiter = normalized.includes(":") ? ":" : "/";
+		const [wRaw, hRaw] = normalized.split(delimiter);
+		const width = Number(wRaw?.trim());
+		const height = Number(hRaw?.trim());
+		if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) return;
+		return width / height;
+	}
+	const numeric = Number(normalized);
+	if (!Number.isFinite(numeric) || numeric <= 0) return void 0;
+	return numeric;
+}
+const MAX_ASPECT_DISTANCE = .25;
+function resolveMediaTransformForAspect(transform, targetAspect) {
+	if (!transform) return {};
+	const base = {
+		rect: transform.rect,
+		hotspot: transform.hotspot,
+		rotation: transform.rotation
+	};
+	const target = parseAspectRatioValue(targetAspect);
+	const crops = transform.aspectCrops;
+	if (!target || !crops || Object.keys(crops).length === 0) return base;
+	let best = null;
+	let bestDistance = Number.POSITIVE_INFINITY;
+	for (const [key, candidate] of Object.entries(crops)) {
+		const candidateAspect = parseAspectRatioValue(candidate.aspect ?? key);
+		if (!candidateAspect) continue;
+		const distance = Math.abs(Math.log(candidateAspect / target));
+		if (distance < bestDistance) {
+			best = candidate;
+			bestDistance = distance;
+		}
+	}
+	if (!best) return base;
+	if (bestDistance > MAX_ASPECT_DISTANCE) return base;
+	return {
+		rect: best.rect ?? base.rect,
+		hotspot: best.hotspot ?? base.hotspot,
+		rotation: best.rotation ?? base.rotation
+	};
+}
+function isValidTransformRect(rect) {
+	return isValidTransformRectStructure(rect);
+}
+function isExplicitRectCrop(rect, sourceWidth, sourceHeight, epsilon = DEFAULT_RECT_EPSILON) {
+	if (!isValidTransformRect(rect)) return false;
+	if (!(typeof sourceWidth === "number" && Number.isFinite(sourceWidth) && sourceWidth > 0 && typeof sourceHeight === "number" && Number.isFinite(sourceHeight) && sourceHeight > 0)) return true;
+	const [x, y, width, height] = rect;
+	return !(Math.abs(x) <= epsilon && Math.abs(y) <= epsilon && Math.abs(width - sourceWidth) <= epsilon && Math.abs(height - sourceHeight) <= epsilon);
+}
+//#endregion
+//#region ../media-core/src/renderableMediaAsset.ts
+function attachRenderableMediaAssetFields(media, asset) {
+	return {
+		...media,
+		assetId: asset.id,
+		id: asset.id,
+		identifier: mediaIdentifierOrFallback(media.identifier, asset.identifier),
+		storageBucket: asset.storageBucket ?? media.storageBucket,
+		storagePath: asset.storagePath ?? media.storagePath,
+		width: asset.width ?? media.width,
+		height: asset.height ?? media.height,
+		mimeType: asset.mimeType ?? media.mimeType
+	};
+}
+/**
+* Preserve an explicit per-usage identifier when one exists. Otherwise prefer
+* the canonical asset identifier, while keeping intentionally blank legacy
+* string values from becoming null.
+*/
+function mediaIdentifierOrFallback(current, fallback) {
+	if (typeof current === "string" && current.trim().length > 0) return current;
+	return fallback ?? (typeof current === "string" ? current : void 0);
+}
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/media.tsx
+const MAX_RENDER_DIMENSION = 4096;
+const RELATIVE_IMG_PROXY_BASE_PATH = "/api/img";
+function getValidSourceDimension(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function isExplicitCropProxyEnabled() {
+	const raw = process.env.NEXT_PUBLIC_MEDIA_EXPLICIT_CROP_PROXY_ENABLED ?? process.env.MEDIA_EXPLICIT_CROP_PROXY_ENABLED;
+	if (!raw) return true;
+	const normalized = raw.trim().toLowerCase();
+	return !(normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off");
+}
+function getRequestedDimension(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+	return Math.min(MAX_RENDER_DIMENSION, Math.max(1, Math.round(value)));
+}
+function mapResizeToFit(resize) {
+	if (resize === "contain") return "clip";
+	return "crop";
+}
+function shouldUseExplicitRectProxy(value, options, resolvedTransform, sourceWidth, sourceHeight) {
+	if ("original" in options && options.original) return false;
+	if (!isExplicitCropProxyEnabled()) return false;
+	if (!value.assetId) return false;
+	if (typeof resolvedTransform.rotation === "number" && resolvedTransform.rotation !== 0) return true;
+	return isExplicitRectCrop(resolvedTransform.rect, sourceWidth, sourceHeight);
+}
+function buildProxyTransformParams(options, resolvedTransform) {
+	const params = {
+		w: "width" in options ? getRequestedDimension(options.width) : void 0,
+		h: "height" in options ? getRequestedDimension(options.height) : void 0,
+		q: "quality" in options ? options.quality : void 0,
+		fit: mapResizeToFit("resize" in options ? options.resize : void 0),
+		autoFormat: true
+	};
+	if (resolvedTransform.rect) params.rect = resolvedTransform.rect;
+	if (resolvedTransform.rotation) params.or = resolvedTransform.rotation;
+	return params;
+}
+function buildDirectTransformOptions(options) {
+	if ("original" in options && options.original) return void 0;
+	return {
+		width: "width" in options ? getRequestedDimension(options.width) : void 0,
+		height: "height" in options ? getRequestedDimension(options.height) : void 0,
+		quality: "quality" in options ? options.quality : void 0,
+		resize: "resize" in options ? options.resize : void 0
+	};
+}
+function resolveTransformResolution(value, targetAspectRatio) {
+	return {
+		resolvedTransform: resolveMediaTransformForAspect(value.transform, targetAspectRatio),
+		sourceWidth: getValidSourceDimension(value.width),
+		sourceHeight: getValidSourceDimension(value.height)
+	};
+}
+function getProxyImageUrl(value, options, transformAspectRatio, resolved) {
+	if (!value.assetId) return void 0;
+	const targetAspect = transformAspectRatio ?? resolveTargetAspectRatio(options);
+	const { resolvedTransform, sourceWidth, sourceHeight } = resolved ?? resolveTransformResolution(value, targetAspect);
+	if (!shouldUseExplicitRectProxy(value, options, resolvedTransform, sourceWidth, sourceHeight)) return void 0;
+	const params = buildProxyTransformParams(options, resolvedTransform);
+	const proxyBasePath = getImageProxyBasePath();
+	const proxyUrl = getImageUrl({ id: unsafeAsMediaAssetId(value.assetId) }, params, proxyBasePath);
+	debugMediaNodeLog("resolve:proxy-img", {
+		assetId: value.assetId,
+		params,
+		proxyBasePath,
+		proxyUrl
+	});
+	return proxyUrl;
+}
+function warnForMediaUrlResolution(result) {
+	switch (result.kind) {
+		case "missing-site-context":
+			console.warn(`[blocks] Relative storagePath "${result.storagePath}" requires siteId context. Media URL may be incorrect. Ensure siteId is set via runWithMediaContext or setContextSiteId.`);
+			return;
+		case "missing-supabase-url":
+			console.warn(`[blocks] ${result.message} Media URL may be unavailable. Ensure NEXT_PUBLIC_SUPABASE_URL is configured or pass supabaseUrl in the media context.`);
+			return;
+		case "invalid-storage-path":
+			console.warn(`[blocks] Invalid media storagePath "${result.storagePath}".`);
+			return;
+		case "resolved":
+		case "unsupported-media-type":
+		case "missing-storage-path":
+		case "missing-image-url": return;
+	}
+}
+function resolveMediaStorageUrlResult(value, context, transformOptions) {
+	const canonical = resolveMediaWithCanonicalAsset(value, context ?? void 0);
+	if (!canonical.storagePath || canonical.storagePath.length === 0) return {
+		kind: "missing-storage-path",
+		assetId: canonical.assetId,
+		identifier: canonical.identifier
+	};
+	const siteId = context?.siteId ?? getSiteId();
+	const bucket = canonical.storageBucket ?? "media";
+	const siteScopedPath = isSiteScopedDirectImageStoragePath(canonical.storagePath) ? canonical.storagePath : null;
+	let supabaseUrl;
+	try {
+		supabaseUrl = context?.supabaseUrl?.replace(/\/$/, "") ?? getSupabaseUrl();
+	} catch (error) {
+		return {
+			kind: "missing-supabase-url",
+			message: error instanceof Error ? error.message : "Supabase URL is not configured."
+		};
+	}
+	let directUrl;
+	if (siteScopedPath) directUrl = getDirectImageUrlForSiteScopedPath(supabaseUrl, siteScopedPath, bucket, transformOptions);
+	else {
+		const relativePath = parseRelativeStoragePath(canonical.storagePath);
+		if (!relativePath.ok) return {
+			kind: "invalid-storage-path",
+			storagePath: canonical.storagePath
+		};
+		if (!siteId) return {
+			kind: "missing-site-context",
+			storagePath: canonical.storagePath
+		};
+		directUrl = getDirectImageUrlForRelativePath(supabaseUrl, relativePath.value, siteId, bucket, transformOptions);
+	}
+	debugMediaNodeLog("resolve:direct-supabase", {
+		storagePath: canonical.storagePath,
+		siteId,
+		bucket,
+		directUrl,
+		transformOptions
+	});
+	return {
+		kind: "resolved",
+		url: directUrl
+	};
+}
+function getDirectImageUrlForValue(value, options, context) {
+	const result = resolveMediaStorageUrlResult(value, context, buildDirectTransformOptions(options));
+	return result.kind === "resolved" ? result.url : void 0;
+}
+function resolveStorageImageUrl(value, options, context, transformAspectRatio, resolved) {
+	const proxyUrl = getProxyImageUrl(value, options, transformAspectRatio, resolved);
+	if (proxyUrl) return proxyUrl;
+	const directUrl = getDirectImageUrlForValue(value, options, context);
+	if (directUrl) return directUrl;
+}
+/**
+* Common image size presets.
+* Use these for consistent sizing across the application.
+*/
+const ImagePresets = {
+	/** Small thumbnails (200px) - for block previews, lists */
+	thumbnail: {
+		width: 200,
+		quality: 80,
+		resize: "contain"
+	},
+	/** Card-sized images (600px) - for cards, grids */
+	card: {
+		width: 600,
+		quality: 80,
+		resize: "contain"
+	},
+	/** Hero images (1200px) - for above-fold content */
+	hero: {
+		width: 1200,
+		quality: 85,
+		resize: "contain"
+	},
+	/** Full-width images (1920px) - for backgrounds, large displays */
+	full: {
+		width: 1920,
+		quality: 85,
+		resize: "contain"
+	}
+};
+/**
+* Server-side: AsyncLocalStorage for request isolation.
+* Prevents race conditions when multiple requests are processed concurrently.
+*
+* Lazy initialization to avoid issues in environments that don't support async_hooks.
+*/
+let _serverStorage = null;
+let _serverStorageChecked = false;
+function getServerStorage() {
+	if (typeof window !== "undefined") return null;
+	if (_serverStorageChecked) return _serverStorage;
+	_serverStorageChecked = true;
+	try {
+		const globalWithNonWebpackRequire = globalThis;
+		const AsyncLocalStorage = (typeof globalWithNonWebpackRequire.__non_webpack_require__ === "function" ? globalWithNonWebpackRequire.__non_webpack_require__ : new Function("id", "return require(id)"))("async_hooks").AsyncLocalStorage;
+		if (AsyncLocalStorage) {
+			_serverStorage = new AsyncLocalStorage();
+			return _serverStorage;
+		}
+		return null;
+	} catch {
+		console.warn("[blocks] AsyncLocalStorage not available - using module-level state");
+		return null;
+	}
+}
+/**
+* Client-side context storage.
+* Safe because browsers are single-threaded per tab.
+*
+* IMPORTANT: This must be shared across bundles.
+* SDK preview mode can load multiple independently-bundled entrypoints
+* (e.g. `@riverbankcms/sdk/rendering` + `@riverbankcms/sdk/preview-next/client`),
+* which can otherwise each get their own module-scoped singleton.
+*/
+const RB_MEDIA_CONTEXT_KEY = Symbol.for("riverbankcms.blocks.mediaContext");
+function getClientContextStore() {
+	const g = globalThis;
+	const existing = g[RB_MEDIA_CONTEXT_KEY];
+	if (existing && typeof existing === "object") return existing;
+	const next = {};
+	g[RB_MEDIA_CONTEXT_KEY] = next;
+	return next;
+}
+/**
+* Get the current media context.
+* Server-side: Uses AsyncLocalStorage for request isolation.
+* Client-side: Uses module-level state (safe in single-threaded browser).
+*/
+function getMediaContext() {
+	const storage = getServerStorage();
+	if (storage) return storage.getStore() ?? {};
+	return getClientContextStore();
+}
+function getCurrentResolveImageUrlContext() {
+	const context = getMediaContext();
+	if (!context.supabaseUrl && !context.siteId && !context.mediaAssetIndex) return;
+	return {
+		supabaseUrl: context.supabaseUrl,
+		siteId: context.siteId,
+		mediaAssetIndex: context.mediaAssetIndex
+	};
+}
+/**
+* Get the Supabase URL for constructing direct storage URLs.
+* Used for serving images directly from Supabase storage CDN.
+*
+* Resolution order:
+* 1. Context URL (set via runWithMediaContext or setContextSupabaseUrl)
+* 2. Environment variable NEXT_PUBLIC_SUPABASE_URL
+*
+* SDK sites receive the URL from the API, so they don't need the env var.
+* Dashboard and frontend apps use the env var.
+*/
+function getSupabaseUrl() {
+	const context = getMediaContext();
+	if (context.supabaseUrl) return context.supabaseUrl;
+	const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+	if (!url) throw new Error("NEXT_PUBLIC_SUPABASE_URL is not configured. Set it to your Supabase project URL (e.g., https://xxx.supabase.co)");
+	return url.replace(/\/$/, "");
+}
+function resolveDashboardOrigin(raw) {
+	if (!raw) return void 0;
+	const trimmed = raw.trim();
+	if (!trimmed) return void 0;
+	const withoutApiSuffix = trimmed.replace(/\/+$/, "").replace(/\/api\/?$/, "");
+	const normalized = /^https?:\/\//i.test(withoutApiSuffix) ? withoutApiSuffix : `http://${withoutApiSuffix.replace(/^\/+/, "")}`;
+	try {
+		return new URL(normalized).origin;
+	} catch {
+		return;
+	}
+}
+function getImageProxyBasePath() {
+	const dashboardOrigin = resolveDashboardOrigin(process.env.NEXT_PUBLIC_DASHBOARD_URL);
+	if (!dashboardOrigin) return RELATIVE_IMG_PROXY_BASE_PATH;
+	return `${dashboardOrigin}${RELATIVE_IMG_PROXY_BASE_PATH}`;
+}
+/**
+* Get the site ID for constructing storage paths.
+* Required for relative path resolution.
+*/
+function getSiteId() {
+	return getMediaContext().siteId;
+}
+function getMediaAssetIndex(context) {
+	return context?.mediaAssetIndex ?? getMediaContext().mediaAssetIndex;
+}
+function resolveCanonicalMediaAsset(value, context) {
+	const index = getMediaAssetIndex(context);
+	if (!index) return void 0;
+	if (value.assetId) {
+		const hit = index.byId.get(value.assetId);
+		if (hit) return hit;
+	}
+	const identifier = typeof value.identifier === "string" ? value.identifier.trim() : "";
+	if (identifier) {
+		const hit = index.byIdentifier.get(identifier);
+		if (hit) return hit;
+	}
+}
+function resolveMediaWithCanonicalAsset(value, context) {
+	const asset = resolveCanonicalMediaAsset(value, context);
+	if (!asset) return value;
+	return attachRenderableMediaAssetFields(value, asset);
+}
+const debugMediaNodeLog = (...args) => {
+	if (typeof window === "undefined") return;
+	if (Reflect.get(window, "__DEBUG_MEDIA_NODE__") === true) console.log("[MediaNode]", ...args);
+};
+function resolveTargetAspectRatio(size) {
+	if ("original" in size) return void 0;
+	if ("width" in size && "height" in size && typeof size.width === "number" && typeof size.height === "number") return size.width / size.height;
+}
+function resolveImageUrlWithContext(value, options, context, transformAspectRatio) {
+	const result = resolveImageUrlWithContextResult(value, options, context, transformAspectRatio);
+	warnForMediaUrlResolution(result);
+	return result.kind === "resolved" ? result.url : void 0;
+}
+function resolveImageUrlWithContextResult(value, options, context, transformAspectRatio) {
+	if (value.type !== "image") return {
+		kind: "unsupported-media-type",
+		mediaType: value.type
+	};
+	const url = resolveImageUrlWithContextInternal(value, options, context ?? void 0, transformAspectRatio);
+	if (url) return {
+		kind: "resolved",
+		url
+	};
+	const canonical = resolveMediaWithCanonicalAsset(value, context ?? void 0);
+	if (canonical.storagePath && canonical.storagePath.length > 0) return resolveMediaStorageUrlResult(canonical, context, buildDirectTransformOptions(options));
+	return {
+		kind: "missing-image-url",
+		assetId: canonical.assetId,
+		identifier: canonical.identifier
+	};
+}
+function resolveImageUrlWithContextInternal(value, options, context, transformAspectRatio, resolved) {
+	if (value.type !== "image") return void 0;
+	const canonical = resolveMediaWithCanonicalAsset(value, context);
+	debugMediaNodeLog("resolveImageUrl input", {
+		assetId: canonical.assetId,
+		storagePath: canonical.storagePath,
+		src: canonical.src,
+		type: canonical.type,
+		options
+	});
+	if (canonical.storagePath && canonical.storagePath.length > 0) {
+		const resolvedStorageUrl = resolveStorageImageUrl(canonical, options, context, transformAspectRatio, resolved);
+		if (resolvedStorageUrl) return resolvedStorageUrl;
+	}
+	if (typeof canonical.src === "string" && canonical.src.length > 0) {
+		debugMediaNodeLog("resolve:explicit-src", { src: canonical.src });
+		return canonical.src;
+	}
+	const legacyUrl = typeof canonical === "object" && canonical !== null ? Reflect.get(canonical, "url") : void 0;
+	debugMediaNodeLog("resolve:fallback-url", { fallbackUrl: typeof legacyUrl === "string" ? legacyUrl : null });
+	return typeof legacyUrl === "string" ? legacyUrl : void 0;
+}
+//#endregion
+//#region ../blocks/src/primitives/content/components/RichText.tsx
+function parseDimension(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.round(value);
+	if (typeof value === "string" && value.trim().length > 0) {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed) && parsed > 0) return Math.round(parsed);
+	}
+}
+function normalizeRel(target, rel) {
+	const normalizedRel = rel?.trim();
+	if (target !== "_blank") return normalizedRel && normalizedRel.length > 0 ? normalizedRel : void 0;
+	const tokens = new Set((normalizedRel ?? "").split(/\s+/).map((token) => token.trim().toLowerCase()).filter(Boolean));
+	tokens.add("noopener");
+	tokens.add("noreferrer");
+	return Array.from(tokens).join(" ");
+}
+function renderMarks(text, marks, key, linkTarget) {
+	if (!marks || marks.length === 0) return text;
+	return marks.reduce((acc, mark) => {
+		switch (mark.type) {
+			case "bold":
+			case "strong": return /* @__PURE__ */ jsx("strong", { children: acc }, `${key}-b`);
+			case "italic":
+			case "em": return /* @__PURE__ */ jsx("em", { children: acc }, `${key}-i`);
+			case "link": {
+				if (typeof acc === "string" && acc.length === 0) return acc;
+				const attrs = mark.attrs ?? {};
+				const href = sanitizeHref(attrs.href);
+				if (!href) return acc;
+				const storedTarget = typeof attrs.target === "string" && attrs.target.trim().length > 0 ? attrs.target.trim() : void 0;
+				const target = linkTarget === "new-tab" ? "_blank" : storedTarget;
+				return /* @__PURE__ */ jsx("a", {
+					href,
+					target,
+					rel: normalizeRel(target, typeof attrs.rel === "string" ? attrs.rel : void 0),
+					children: acc
+				}, `${key}-l`);
+			}
+			default: return acc;
+		}
+	}, text);
+}
+function renderDoc(node, key, imageResolveContext, linkTarget) {
+	if (!node || !node.type) return null;
+	const children = node.content?.map((child, index) => renderDoc(child, `${key}-${index}`, imageResolveContext, linkTarget));
+	switch (node.type) {
+		case "doc": return /* @__PURE__ */ jsx(Fragment, { children });
+		case "paragraph":
+			if (!children && !node.text) return /* @__PURE__ */ jsx("p", {}, key);
+			return /* @__PURE__ */ jsx("p", { children: children ?? renderMarks(node.text ?? "", node.marks, key, linkTarget) }, key);
+		case "heading": {
+			const headingTag = `h${Math.min(Math.max(node.attrs?.level ?? 2, 1), 6)}`;
+			return React.createElement(headingTag, { key }, children);
+		}
+		case "bulletList": return /* @__PURE__ */ jsx("ul", { children }, key);
+		case "orderedList": return /* @__PURE__ */ jsx("ol", { children }, key);
+		case "listItem": return /* @__PURE__ */ jsx("li", { children }, key);
+		case "blockquote": return /* @__PURE__ */ jsx("blockquote", { children }, key);
+		case "horizontalRule": return /* @__PURE__ */ jsx("hr", {}, key);
+		case "hardBreak": return /* @__PURE__ */ jsx("br", {}, key);
+		case "image": {
+			const attrs = node.attrs ?? {};
+			const src = typeof attrs.src === "string" ? attrs.src.trim() : "";
+			const identifier = typeof attrs.identifier === "string" ? attrs.identifier.trim() : "";
+			const alt = typeof attrs.alt === "string" ? attrs.alt : "";
+			const title = typeof attrs.title === "string" && attrs.title.trim().length > 0 ? attrs.title : void 0;
+			const width = parseDimension(attrs.width);
+			const height = parseDimension(attrs.height);
+			const resolvedSrc = src || (identifier ? resolveImageUrlWithContext({
+				type: "image",
+				identifier
+			}, width ? {
+				width,
+				resize: "contain",
+				quality: 85
+			} : height ? {
+				height,
+				resize: "contain",
+				quality: 85
+			} : ImagePresets.full, imageResolveContext ?? void 0) ?? "" : "");
+			if (!resolvedSrc) return null;
+			return /* @__PURE__ */ jsx("img", {
+				src: resolvedSrc,
+				alt,
+				title,
+				width,
+				height,
+				loading: "lazy",
+				decoding: "async"
+			}, key);
+		}
+		case "text": return renderMarks(node.text ?? "", node.marks, key, linkTarget);
+		default: return null;
+	}
+}
+const DEFAULT_RICH_TEXT_CLASS = "rb-prose rb-max-w-none";
+function RichText({ as: Comp = "div", className, doc, path, linkTarget = "stored" }) {
+	const imageResolveContext = getCurrentResolveImageUrlContext() ?? null;
+	const content = doc ? renderDoc(doc, "doc", imageResolveContext, linkTarget) : null;
+	const dataAttributes = path ? { "data-builder-richtext": path } : void 0;
+	return /* @__PURE__ */ jsx(Comp, {
+		className: className?.trim() || DEFAULT_RICH_TEXT_CLASS,
+		...dataAttributes,
+		children: content
+	});
+}
+//#endregion
+//#region ../blocks/src/system/runtime/shared/components/BookingConsentAgreement.tsx
+function BookingConsentAgreement({ agreement, showTitle = true, title, titleId }) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [showTitle ? /* @__PURE__ */ jsxs("div", {
+		id: titleId,
+		className: "form-label",
+		children: [title, /* @__PURE__ */ jsx("span", {
+			className: "required-marker",
+			children: "*"
+		})]
+	}) : null, /* @__PURE__ */ jsx("div", {
+		role: "group",
+		"aria-label": showTitle ? void 0 : title,
+		"aria-labelledby": showTitle ? titleId : void 0,
+		children: /* @__PURE__ */ jsx(RichText, {
+			doc: agreement,
+			linkTarget: "new-tab",
+			className: "rb-prose rb-max-w-none"
+		})
+	})] });
+}
+//#endregion
 //#region ../blocks/src/system/runtime/nodes/booking-form.default-ui.tsx
 function optionCardClassName(isSelected) {
 	return `rb-option-card${isSelected ? " rb-option-card--selected" : ""}`;
@@ -12864,7 +13762,11 @@ function DefaultDynamicField({ booking, field }) {
 	return /* @__PURE__ */ jsxs("div", {
 		className: "rb-space-y-2",
 		children: [
-			/* @__PURE__ */ jsxs("label", {
+			field.field.type === "booking_requirement_consent" ? /* @__PURE__ */ jsx(BookingConsentAgreement, {
+				agreement: field.field.agreement,
+				title: field.label,
+				titleId: field.labelId
+			}) : /* @__PURE__ */ jsxs("label", {
 				id: field.labelId,
 				htmlFor: field.inputId,
 				className: "form-label",
@@ -12909,7 +13811,7 @@ function DefaultFieldInput({ describedBy, error, errorId, field, onBlur, onChang
 		required: field.required,
 		...validationProps
 	};
-	switch (field.type) {
+	switch (field.field.type) {
 		case "textarea": return /* @__PURE__ */ jsx("textarea", {
 			...commonProps,
 			value: strValue,
@@ -13023,7 +13925,7 @@ function DefaultFieldInput({ describedBy, error, errorId, field, onBlur, onChang
 				className: "form-checkbox rb-mt-0.5"
 			}), /* @__PURE__ */ jsx("span", {
 				className: "rb-caption",
-				children: field.field.placeholder || field.label
+				children: field.field.checkboxLabel
 			})]
 		});
 		case "number": return /* @__PURE__ */ jsx("input", {
@@ -13092,10 +13994,10 @@ function DefaultBookingDiscount({ booking }) {
 			children: /* @__PURE__ */ jsxs("p", {
 				className: "ab-text",
 				children: [
-					"Discount available: ",
-					booking.discount.autoAppliedDiscount.publicLabel,
+					"Discount available:",
 					" ",
-					"will apply automatically at checkout."
+					booking.discount.autoAppliedDiscount.publicLabel,
+					" will apply automatically at checkout."
 				]
 			})
 		}) : null]
@@ -13680,11 +14582,21 @@ function readAmount(value) {
 }
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/validation.ts
-function validateFormData(formData) {
+function createInitialRegistrationFormData() {
+	return {
+		name: "",
+		email: "",
+		phone: "",
+		notes: "",
+		consentAccepted: false
+	};
+}
+function validateFormData(formData, requiresConsent = false) {
 	const errors = {};
 	if (!formData.name.trim()) errors.name = "Name is required";
 	if (!formData.email.trim()) errors.email = "Email is required";
 	else if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(formData.email)) errors.email = "Invalid email address";
+	if (requiresConsent && formData.consentAccepted !== true) errors.consentAccepted = "Please read and accept the agreement before continuing.";
 	return errors;
 }
 /**
@@ -14608,6 +15520,7 @@ function useEventRegistrationSubmitWithDeps(options, deps) {
 				name: options.formData.name.trim(),
 				phone: options.formData.phone.trim() || void 0,
 				notes: options.formData.notes.trim() || void 0,
+				consentAccepted: options.formData.consentAccepted,
 				altchaSolution: options.altchaSolution,
 				paymentMethod: method,
 				customerPassId: method === "pass" ? passId : void 0,
@@ -14825,75 +15738,6 @@ function requiresPaymentStep(params) {
 	return !isEntitlementSelection(params.paymentSelection);
 }
 //#endregion
-//#region ../blocks/src/system/manifest/richTextSchema.ts
-/**
-* Shared Rich Text Schema
-*
-* This module provides a single source of truth for TipTap rich text validation
-* across both the block-form editor and the block rendering system.
-*
-* Rich-text fields use one canonical root shape:
-* `{ type: 'doc', content: [...] }`.
-*/
-/**
-* TipTap document node schema (recursive structure)
-*
-* Supports the full TipTap document structure including:
-* - type: Node type (e.g., 'doc', 'paragraph', 'text')
-* - content: Nested array of child nodes
-* - text: Text content for text nodes
-* - attrs: Node attributes (e.g., alignment, color)
-* - marks: Text formatting marks (e.g., bold, italic)
-*/
-const TipTapMarkSchema = z.object({
-	type: z.string().min(1),
-	attrs: z.record(z.string(), z.unknown()).optional()
-}).strict();
-const TipTapNodeSchema = z.lazy(() => z.object({
-	type: z.string().min(1),
-	content: z.array(TipTapNodeSchema).optional(),
-	text: z.string().optional(),
-	attrs: z.record(z.string(), z.unknown()).optional(),
-	marks: z.array(TipTapMarkSchema).optional()
-}).strict().superRefine((node, ctx) => {
-	if (node.type === "doc") ctx.addIssue({
-		code: "custom",
-		path: ["type"],
-		message: "Document nodes are only valid at the rich-text root"
-	});
-	if (node.type === "text") {
-		if (node.text === void 0 || node.text.length === 0) ctx.addIssue({
-			code: "custom",
-			path: ["text"],
-			message: "Text nodes require a non-empty text value"
-		});
-		if (node.content !== void 0) ctx.addIssue({
-			code: "custom",
-			path: ["content"],
-			message: "Text nodes cannot contain child nodes"
-		});
-		return;
-	}
-	if (node.text !== void 0) ctx.addIssue({
-		code: "custom",
-		path: ["text"],
-		message: "Only text nodes can contain a text value"
-	});
-}));
-/**
-* Canonical schema for a TipTap rich-text document root.
-*
-* Stricter than {@link TipTapNodeSchema}: `type` is literally `'doc'` and
-* `content` is required (possibly empty). This is the shape every producer
-* (dummy content, editor output, migrations) must emit, and the shape every
-* non-legacy consumer can rely on.
-*
-*/
-const RichTextDocSchema = z.object({
-	type: z.literal("doc"),
-	content: z.array(TipTapNodeSchema)
-}).strict();
-//#endregion
 //#region ../blocks/src/system/blocks/events/whole-series/pricing.ts
 function isSaleWindowOpen(option, now) {
 	if (!option.isActive) return false;
@@ -15116,6 +15960,7 @@ const publicWholeSeriesOfferingSchema = z.object({
 	pricing: wholeSeriesPricingSchema,
 	currency: z.string(),
 	paymentTerms: blockBookingPaymentTermsSchema,
+	consent: blockBookingConsentSchema.nullable(),
 	enrollmentCapacity: z.number().nullable(),
 	acceptsMemberships: z.boolean(),
 	status: z.enum([
@@ -15433,6 +16278,7 @@ const publicEventSchema = z.object({
 	timeZone: z.string(),
 	pricing: publicEventPricingSchema,
 	paymentTerms: blockBookingPaymentTermsSchema,
+	consent: blockBookingConsentSchema.nullable(),
 	accessRestriction: accessRestrictionSchema,
 	allowedCategoryIds: z.array(z.string()),
 	requireGuestDetails: z.boolean().optional(),
@@ -15951,12 +16797,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	const step = flowState.step;
 	const paymentSelection = flowState.paymentSelection;
 	const [selectedEvent, setSelectedEvent] = useState(preSelectedEvent ?? null);
-	const [formData, setFormData] = useState({
-		name: "",
-		email: "",
-		phone: "",
-		notes: ""
-	});
+	const [formData, setFormData] = useState(createInitialRegistrationFormData);
 	const [errors, setErrors] = useState({});
 	const [guests, setGuests] = useState([]);
 	const [guestErrors, setGuestErrors] = useState({});
@@ -16254,7 +17095,7 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 		guests
 	]);
 	const validateForm = () => {
-		const newErrors = validateFormData(formData);
+		const newErrors = validateFormData(formData, Boolean(currentEvent?.consent));
 		setErrors(newErrors);
 		const newGuestErrors = {};
 		if (requireGuestDetails && guests.length > 0) {
@@ -16443,6 +17284,10 @@ function useEventRegistrationWizardWithDeps(options, deps) {
 	});
 	const handleEventSelect = (event) => {
 		setSelectedEvent(event);
+		setFormData((current) => ({
+			...current,
+			consentAccepted: false
+		}));
 		const slidingScale = getSlidingScaleForEvent(event);
 		setSelectedSlidingAmountInput(slidingScale?.suggestedAmount !== null && slidingScale?.suggestedAmount !== void 0 ? formatCentsAsCurrencyInput$1(slidingScale.suggestedAmount) : "");
 		setSelectedAttendanceMode((event.deliveryMode ?? "in_person") === "hybrid" ? null : (event.deliveryMode ?? "in_person") === "online" ? "online" : "in_person");
@@ -17328,6 +18173,7 @@ function validateSubmission(state, setters) {
 		message: "Choose an available set of dates to continue."
 	};
 	const errors = validateFormData$1(state.formData);
+	if (state.selectedRun.consent && state.formData.consentAccepted !== true) errors.consentAccepted = "Please read and accept the agreement before continuing.";
 	setters.setErrors(errors);
 	if (Object.keys(errors).length > 0) return { kind: "validation-failed" };
 	const pricingMessage = getMissingWholeSeriesPricingSelectionMessage(state.pricing);
@@ -17351,6 +18197,7 @@ function registrantPayload(state) {
 		name: state.formData.name.trim(),
 		phone: state.formData.phone.trim() || void 0,
 		formData: { notes: state.formData.notes.trim() || void 0 },
+		consentAccepted: state.formData.consentAccepted,
 		altchaSolution: state.altchaSolution,
 		claimToken: state.claimToken ?? void 0
 	};
@@ -17474,7 +18321,8 @@ const EMPTY_FORM = {
 	name: "",
 	email: "",
 	phone: "",
-	notes: ""
+	notes: "",
+	consentAccepted: false
 };
 function useWholeSeriesRegistrationPortal(api) {
 	const [formData, setFormData] = useState(EMPTY_FORM);
@@ -18080,6 +18928,7 @@ function toPublicWholeSeriesOffering(run) {
 		slug: run.slug,
 		description: run.description,
 		teamMembers: run.teamMembers ? [...run.teamMembers] : void 0,
+		consent: run.consent,
 		enrollmentOpen: run.registrationOpen,
 		pricing,
 		currency: run.pricing.currency,