riverbankcms 0.1.0 → 0.2.2

package/dist/src-XEJYAKbQ.mjs

@@ -0,0 +1,4697 @@
+#!/usr/bin/env node
+//#region ../core/src/result.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+
+//#endregion
+//#region ../core/src/branded.ts
+const UUID_PATTERN$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseUuidBrand(value, unsafeConstructor) {
+	if (typeof value !== "string") {
+		return err({ kind: "not_string" });
+	}
+	const normalized = value.trim().toLowerCase();
+	if (normalized.length === 0) {
+		return err({ kind: "empty_string" });
+	}
+	if (!UUID_PATTERN$1.test(normalized)) {
+		return err({ kind: "invalid_uuid" });
+	}
+	return ok(unsafeConstructor(normalized));
+}
+function expectParsedBrandedId(result) {
+	if (!result.ok) {
+		throw new Error(`Expected a validated branded UUID (${result.error.kind}).`);
+	}
+	return result.value;
+}
+const unsafeAsEntryId = (id) => id;
+/**
+* Mint a preview-fixture entry id. Unsafe at the type level because the
+* function can't verify the input string is actually shaped as a preview
+* id — the predicate `isPreviewEntryId` is the recommended narrowing path.
+*/
+const unsafeAsPreviewEntryId = (id) => id;
+const unsafeAsEventInstanceId = (id) => id;
+const unsafeAsSiteId = (id) => id;
+const unsafeAsApiKeyId = (id) => id;
+const unsafeAsSiteRouteId = (id) => id;
+const unsafeAsPageId = (id) => id;
+const unsafeAsPageSurfaceId = (id) => id;
+const unsafeAsOccurrenceId = (id) => id;
+const unsafeAsEventOfferingId = (id) => id;
+const unsafeAsEventSeriesId = (id) => id;
+const unsafeAsEventPageRouteSlug = (value) => value;
+const unsafeAsTicketTypeId = (id) => id;
+const unsafeAsEventCategoryId = (id) => id;
+const unsafeAsVenueId = (id) => id;
+const unsafeAsPricingOptionId = (id) => id;
+const unsafeAsMoneyDateString = (value) => value;
+const unsafeAsStripeCheckoutSessionId = (value) => value;
+const unsafeAsProductId = (id) => id;
+const unsafeAsProductVariantId = (id) => id;
+const unsafeAsProductCategoryId = (id) => id;
+const unsafeAsMediaAssetId = (id) => id;
+const unsafeAsUploadSessionId = (id) => id;
+const unsafeAsStorageBucketName = (value) => value;
+const unsafeAsStoragePath = (value) => value;
+const unsafeAsRelativeStoragePath = (value) => value;
+const unsafeAsSiteScopedStoragePath = (value) => value;
+const unsafeAsFileChecksumSha256 = (value) => value;
+const unsafeAsDetectedMimeType = (value) => value;
+const unsafeAsDeclaredMimeType = (value) => value;
+const unsafeAsOriginalFilename = (value) => value;
+const unsafeAsSafeDownloadFilename = (value) => value;
+const unsafeAsPositiveByteCount = (value) => value;
+const unsafeAsPositiveSeconds = (value) => value;
+const unsafeAsBookingSessionId = (id) => id;
+const unsafeAsDatedOfferingCapacityHoldId = (value) => value;
+const unsafeAsDatedOfferingCapacityHoldAuditRef = (value) => value;
+const unsafeAsDatedOfferingRevocationAuditEventId = (value) => value;
+const unsafeAsDatedOfferingNonCashProjectionClaimToken = (value) => value;
+const unsafeAsDatedOfferingWaitlistCapacityEffectId = (value) => value;
+const unsafeAsDatedOfferingWaitlistCapacityEffectClaimToken = (value) => value;
+const unsafeAsDatedOfferingRunCancellationOperationId = (value) => value;
+const unsafeAsEntitlementId = (id) => id;
+const unsafeAsSiteFontId = (id) => id;
+const unsafeAsUserId = (id) => id;
+const unsafeAsFormId = (id) => id;
+const unsafeAsFormSubmissionId = (id) => id;
+const unsafeAsPassId = (id) => id;
+const unsafeAsMembershipId = (id) => id;
+const unsafeAsCourseId = (id) => id;
+const unsafeAsCourseProgramId = (id) => id;
+const unsafeAsCustomerId = (id) => id;
+const unsafeAsOrderId = (id) => id;
+const unsafeAsOrderItemId = (id) => id;
+const unsafeAsOrderRefundId = (id) => id;
+const unsafeAsOrderPaymentReceiptId = (id) => id;
+const unsafeAsOrderFlexibleBalanceContractId = (id) => id;
+const unsafeAsOrderPaymentPlanId = (id) => id;
+const unsafeAsOrderPaymentPlanInstalmentId = (id) => id;
+const unsafeAsManualPaymentOperationId = (id) => id;
+const unsafeAsCheckoutLineId = (id) => id;
+const unsafeAsAttendeeId = (id) => id;
+const unsafeAsCustomerPassId = (id) => id;
+const unsafeAsCustomerMembershipId = (id) => id;
+const unsafeAsEnrollmentId = (id) => id;
+const unsafeAsAppointmentId = (id) => id;
+const unsafeAsAppointmentServiceId = (id) => id;
+const unsafeAsAppointmentResourceId = (id) => id;
+const unsafeAsAppointmentReservationId = (id) => id;
+const unsafeAsAppointmentReservationRunId = (id) => id;
+const unsafeAsAppointmentPaymentRequestId = (id) => id;
+const unsafeAsStaffMemberId = (id) => id;
+const unsafeAsBookingCalendarFeedTokenId = (id) => id;
+const unsafeAsBookingCalendarFeedTokenPublicId = (id) => id;
+const unsafeAsBookingCalendarFeedTokenSecret = (value) => value;
+const unsafeAsBookingCalendarFeedTokenSecretHash = (value) => value;
+const unsafeAsContentEntryId = (id) => id;
+const unsafeAsContentBlockId = (id) => id;
+const unsafeAsContentVersionId = (id) => id;
+const unsafeAsEntryContentHash = (value) => value;
+const unsafeAsStripeInvoiceId = (id) => id;
+const unsafeAsNewsletterSubscriberId = (id) => id;
+const unsafeAsNavigationMenuId = (id) => id;
+const unsafeAsNavigationItemId = (id) => id;
+const unsafeAsEmailAuditRowId = (id) => id;
+const unsafeAsWaitlistEntryId = (id) => id;
+const unsafeAsWaitlistHoldId = (id) => id;
+const unsafeAsShipmentId = (id) => id;
+const unsafeAsActivityLogEntryId = (id) => id;
+const unsafeAsDemoBlueprintId = (id) => id;
+const unsafeAsDemoBlueprintVersionId = (id) => id;
+const unsafeAsDemoInstanceId = (id) => id;
+const unsafeAsDemoClaimId = (id) => id;
+const unsafeAsDemoLifecycleAuditEventId = (id) => id;
+const unsafeAsDemoRuntimeId = (id) => id;
+const unsafeAsDemoCapability = (value) => value;
+const unsafeAsDemoPaymentFlowId = (id) => id;
+const unsafeAsDemoClaimTtlHours = (value) => value;
+const unsafeAsGiftingOfferId = (id) => id;
+const unsafeAsGiftingInstrumentId = (id) => id;
+const unsafeAsBookingRequirementId = (id) => id;
+const unsafeAsBookingRequirementEvidenceId = (id) => id;
+const unsafeAsBookingRequirementDocumentUploadId = (id) => id;
+const unsafeAsBookingRequirementEvidenceAttachmentId = (id) => id;
+const unsafeAsParticipantId = (id) => id;
+const unsafeAsParticipantParticipationId = (id) => id;
+const unsafeAsParticipantRosterAssertionJobId = (id) => id;
+const unsafeAsParticipantBookingQuestionsTaskId = (id) => id;
+const unsafeAsEventAttendeeGuestId = (id) => id;
+const unsafeAsPersonRecordId = (id) => id;
+const unsafeAsEncounterRecordId = (id) => id;
+const unsafeAsRecordEntryId = (id) => id;
+const unsafeAsProtectedPayloadKeyVersion = (id) => id;
+const parseSiteId = (value) => parseUuidBrand(value, unsafeAsSiteId);
+const parseApiKeyId = (value) => parseUuidBrand(value, unsafeAsApiKeyId);
+const parseSiteRouteId = (value) => parseUuidBrand(value, unsafeAsSiteRouteId);
+const parsePageId = (value) => parseUuidBrand(value, unsafeAsPageId);
+const parsePageSurfaceId = (value) => parseUuidBrand(value, unsafeAsPageSurfaceId);
+const parseOccurrenceId = (value) => parseUuidBrand(value, unsafeAsOccurrenceId);
+const parseEventOfferingId = (value) => parseUuidBrand(value, unsafeAsEventOfferingId);
+const parseCourseProgramId = (value) => parseUuidBrand(value, unsafeAsCourseProgramId);
+const parseTicketTypeId = (value) => parseUuidBrand(value, unsafeAsTicketTypeId);
+const parsePricingOptionId = (value) => parseUuidBrand(value, unsafeAsPricingOptionId);
+const parseUserId = (value) => parseUuidBrand(value, unsafeAsUserId);
+const parseProductId = (value) => parseUuidBrand(value, unsafeAsProductId);
+const parseProductVariantId = (value) => parseUuidBrand(value, unsafeAsProductVariantId);
+const parseProductCategoryId = (value) => parseUuidBrand(value, unsafeAsProductCategoryId);
+const parseMediaAssetId = (value) => parseUuidBrand(value, unsafeAsMediaAssetId);
+const parseContentEntryId = (value) => parseUuidBrand(value, unsafeAsContentEntryId);
+const parseContentBlockId = (value) => parseUuidBrand(value, unsafeAsContentBlockId);
+const parseContentVersionId = (value) => parseUuidBrand(value, unsafeAsContentVersionId);
+const parseNavigationMenuId = (value) => parseUuidBrand(value, unsafeAsNavigationMenuId);
+const parseNavigationItemId = (value) => parseUuidBrand(value, unsafeAsNavigationItemId);
+const parsePassId = (value) => parseUuidBrand(value, unsafeAsPassId);
+const parseMembershipId = (value) => parseUuidBrand(value, unsafeAsMembershipId);
+const parseCourseId = (value) => parseUuidBrand(value, unsafeAsCourseId);
+const parseFormId = (value) => parseUuidBrand(value, unsafeAsFormId);
+const parseAppointmentId = (value) => parseUuidBrand(value, unsafeAsAppointmentId);
+const parseAppointmentServiceId = (value) => parseUuidBrand(value, unsafeAsAppointmentServiceId);
+const parseAppointmentResourceId = (value) => parseUuidBrand(value, unsafeAsAppointmentResourceId);
+const parseAppointmentReservationId = (value) => parseUuidBrand(value, unsafeAsAppointmentReservationId);
+const parseAppointmentReservationRunId = (value) => parseUuidBrand(value, unsafeAsAppointmentReservationRunId);
+const parseAttendeeId = (value) => parseUuidBrand(value, unsafeAsAttendeeId);
+const parseDatedOfferingCapacityHoldId = (value) => parseUuidBrand(value, unsafeAsDatedOfferingCapacityHoldId);
+const parseDatedOfferingCapacityHoldAuditRef = (value) => parseUuidBrand(value, unsafeAsDatedOfferingCapacityHoldAuditRef);
+const parseDatedOfferingRevocationAuditEventId = (value) => parseUuidBrand(value, unsafeAsDatedOfferingRevocationAuditEventId);
+const parseDatedOfferingNonCashProjectionClaimToken = (value) => parseUuidBrand(value, unsafeAsDatedOfferingNonCashProjectionClaimToken);
+const parseDatedOfferingWaitlistCapacityEffectId = (value) => parseUuidBrand(value, unsafeAsDatedOfferingWaitlistCapacityEffectId);
+const parseDatedOfferingWaitlistCapacityEffectClaimToken = (value) => parseUuidBrand(value, unsafeAsDatedOfferingWaitlistCapacityEffectClaimToken);
+const parseDatedOfferingRunCancellationOperationId = (value) => parseUuidBrand(value, unsafeAsDatedOfferingRunCancellationOperationId);
+const parseCustomerId = (value) => parseUuidBrand(value, unsafeAsCustomerId);
+const parseCustomerPassId = (value) => parseUuidBrand(value, unsafeAsCustomerPassId);
+const parseCustomerMembershipId = (value) => parseUuidBrand(value, unsafeAsCustomerMembershipId);
+const parseEventSeriesId = (value) => parseUuidBrand(value, unsafeAsEventSeriesId);
+const parseEnrollmentId = (value) => parseUuidBrand(value, unsafeAsEnrollmentId);
+const parseParticipantId = (value) => parseUuidBrand(value, unsafeAsParticipantId);
+const parseParticipantParticipationId = (value) => parseUuidBrand(value, unsafeAsParticipantParticipationId);
+const parseOrderItemId = (value) => parseUuidBrand(value, unsafeAsOrderItemId);
+const parseOrderId = (value) => parseUuidBrand(value, unsafeAsOrderId);
+const parseOrderRefundId = (value) => parseUuidBrand(value, unsafeAsOrderRefundId);
+const parseOrderPaymentReceiptId = (value) => parseUuidBrand(value, unsafeAsOrderPaymentReceiptId);
+const parseOrderFlexibleBalanceContractId = (value) => parseUuidBrand(value, unsafeAsOrderFlexibleBalanceContractId);
+const parseOrderPaymentPlanId = (value) => parseUuidBrand(value, unsafeAsOrderPaymentPlanId);
+const parseOrderPaymentPlanInstalmentId = (value) => parseUuidBrand(value, unsafeAsOrderPaymentPlanInstalmentId);
+const parseManualPaymentOperationId = (value) => parseUuidBrand(value, unsafeAsManualPaymentOperationId);
+
+//#endregion
+//#region ../core/src/date-math.ts
+function addDaysToDate(date, dayCount) {
+	const next = new Date(date);
+	next.setUTCDate(next.getUTCDate() + dayCount);
+	return next;
+}
+function addDaysToIso(isoString, dayCount) {
+	const date = new Date(isoString);
+	if (!Number.isFinite(date.getTime())) {
+		return isoString;
+	}
+	return addDaysToDate(date, dayCount).toISOString();
+}
+function subtractDaysFromIso(isoString, dayCount) {
+	return addDaysToIso(isoString, -dayCount);
+}
+
+//#endregion
+//#region ../core/src/duration.ts
+const DURATION_UNIT_MINUTES = {
+	minutes: 1,
+	hours: 60,
+	days: 60 * 24,
+	weeks: 60 * 24 * 7
+};
+const UNIT_LABELS_SINGULAR = {
+	minutes: "minute",
+	hours: "hour",
+	days: "day",
+	weeks: "week"
+};
+const UNIT_LABELS_PLURAL = {
+	minutes: "minutes",
+	hours: "hours",
+	days: "days",
+	weeks: "weeks"
+};
+function formatDurationUnitLabel(unit, count) {
+	return count === 1 ? UNIT_LABELS_SINGULAR[unit] : UNIT_LABELS_PLURAL[unit];
+}
+/**
+* Picks the coarsest allowed unit that cleanly divides `minutes`. Falls back
+* to the smallest allowed unit when no clean divisor exists.
+*/
+function pickDurationDisplayUnit(minutes, allowed) {
+	if (allowed.length === 0) return "minutes";
+	if (minutes === 0) return allowed[0] ?? "minutes";
+	const sortedDesc = [...allowed].sort((a, b) => DURATION_UNIT_MINUTES[b] - DURATION_UNIT_MINUTES[a]);
+	for (const unit of sortedDesc) {
+		const unitMinutes = DURATION_UNIT_MINUTES[unit];
+		if (minutes >= unitMinutes && minutes % unitMinutes === 0) return unit;
+	}
+	return allowed[0] ?? "minutes";
+}
+/**
+* Guarantees the widget invariant `displayValue x unit === storedMinutes` is
+* representable by prepending minutes when no caller-provided unit divides.
+*/
+function expandAllowedDurationUnits(value, base) {
+	if (base.includes("minutes")) return base;
+	const dividesAny = base.some((unit) => DURATION_UNIT_MINUTES[unit] > 0 && value % DURATION_UNIT_MINUTES[unit] === 0);
+	return dividesAny ? base : ["minutes", ...base];
+}
+function clampDurationMinutes(value, min, max) {
+	let result = value;
+	if (typeof min === "number" && result < min) result = min;
+	if (typeof max === "number" && result > max) result = max;
+	return result;
+}
+
+//#endregion
+//#region ../core/src/demo-capability-policy.ts
+const demoSurfaceClassificationValues = [
+	"allowed",
+	"blocked-hidden",
+	"blocked-disabled",
+	"internal-only",
+	"needs-classification"
+];
+/** Evaluates a classified demo mutation surface and fails closed for inactive claims or unknown surfaces. */
+function evaluateDemoCapability(input) {
+	const classification = input.classification;
+	if (input.claim.kind !== "active") {
+		return {
+			allowed: false,
+			classification,
+			reason: "claim_not_active",
+			surface: input.surface
+		};
+	}
+	switch (classification) {
+		case "allowed": return {
+			allowed: true,
+			classification: "allowed"
+		};
+		case "blocked-hidden":
+		case "blocked-disabled": return {
+			allowed: false,
+			classification,
+			reason: "dangerous_surface",
+			surface: input.surface
+		};
+		case "internal-only": return {
+			allowed: false,
+			classification: "internal-only",
+			reason: "internal_only",
+			surface: input.surface
+		};
+		case "needs-classification": return {
+			allowed: false,
+			classification: "needs-classification",
+			reason: "surface_not_classified",
+			surface: input.surface
+		};
+		default: return assertNever(classification);
+	}
+}
+
+//#endregion
+//#region ../core/src/demo-claim-access.ts
+function deriveDemoClaimAccessState(input) {
+	if (input.instance.status !== "claimed") {
+		return { kind: input.instance.status === "expired" ? "expired" : "missing" };
+	}
+	if (input.claim === null) {
+		return { kind: "missing" };
+	}
+	if (input.claim.status === "released") {
+		return { kind: "released" };
+	}
+	if (input.claim.status === "expired") {
+		return { kind: "expired" };
+	}
+	if (new Date(input.claim.expiresAt).getTime() <= input.now.getTime()) {
+		return { kind: "expired" };
+	}
+	return { kind: "active" };
+}
+
+//#endregion
+//#region ../core/src/demo-lifecycle-status.ts
+const demoBlueprintStatusValues = [
+	"draft",
+	"published",
+	"archived"
+];
+const demoInstanceStatusValues = [
+	"warming",
+	"available",
+	"claimed",
+	"expired",
+	"recycling",
+	"failed"
+];
+const demoClaimStatusValues = [
+	"active",
+	"expired",
+	"released"
+];
+const demoBlueprintArtifactKindValues = ["site_backup", "manual_snapshot"];
+function narrowDemoInstanceStatus(value) {
+	if (demoInstanceStatusValues.includes(value)) {
+		return value;
+	}
+	throw new Error(`Unexpected demo instance status: ${value}`);
+}
+function narrowDemoClaimStatus(value) {
+	if (demoClaimStatusValues.includes(value)) {
+		return value;
+	}
+	throw new Error(`Unexpected demo claim status: ${value}`);
+}
+function narrowDemoBlueprintArtifactKind(value) {
+	if (demoBlueprintArtifactKindValues.includes(value)) {
+		return value;
+	}
+	throw new Error(`Unexpected demo blueprint artifact kind: ${value}`);
+}
+
+//#endregion
+//#region ../core/src/demo-runtime.ts
+const RIVERBANK_RUNTIME_ENV_VAR = "RIVERBANK_RUNTIME_ENV";
+const riverbankRuntimeEnvValues = [
+	"production",
+	"staging",
+	"demo"
+];
+const runtimeByEnv = {
+	production: {
+		kind: "production",
+		demoAllowed: false
+	},
+	staging: {
+		kind: "staging",
+		demoAllowed: false
+	},
+	demo: {
+		kind: "demo",
+		demoAllowed: true
+	}
+};
+function parseRiverbankRuntimeEnv(rawValue) {
+	if (rawValue == null || rawValue.trim() === "") {
+		return {
+			kind: "invalid",
+			error: {
+				kind: "missing_runtime_env",
+				envVar: RIVERBANK_RUNTIME_ENV_VAR
+			}
+		};
+	}
+	const normalizedValue = rawValue.trim().toLowerCase();
+	if (isRiverbankRuntimeEnv(normalizedValue)) {
+		return {
+			kind: "resolved",
+			runtime: runtimeByEnv[normalizedValue]
+		};
+	}
+	return {
+		kind: "invalid",
+		error: {
+			kind: "unsupported_runtime_env",
+			envVar: RIVERBANK_RUNTIME_ENV_VAR,
+			rawValue,
+			normalizedValue,
+			supportedValues: riverbankRuntimeEnvValues
+		}
+	};
+}
+function resolveRiverbankRuntimeEnv(env) {
+	return parseRiverbankRuntimeEnv(env[RIVERBANK_RUNTIME_ENV_VAR]);
+}
+function requireDemoRuntime(resolution) {
+	if (resolution.kind === "invalid") {
+		return {
+			allowed: false,
+			reason: resolution.error.kind,
+			error: resolution.error
+		};
+	}
+	if (resolution.runtime.kind === "demo") {
+		return {
+			allowed: true,
+			runtime: resolution.runtime
+		};
+	}
+	return {
+		allowed: false,
+		reason: "not_demo_runtime",
+		runtime: resolution.runtime
+	};
+}
+function isRiverbankRuntimeEnv(value) {
+	return riverbankRuntimeEnvValues.includes(value);
+}
+
+//#endregion
+//#region ../core/src/collections.ts
+function dedupeStrings(values) {
+	return [...new Set(values)];
+}
+
+//#endregion
+//#region ../core/src/assert-never.ts
+function assertNever(value, message = "Unexpected variant") {
+	throw new Error(`${message}: ${String(value)}`);
+}
+
+//#endregion
+//#region ../core/src/currency-format.ts
+const CURRENCY_CODE_INPUT_PATTERN = /^[A-Za-z]{3}$/;
+const CANONICAL_CURRENCY_CODE_PATTERN = /^[A-Z]{3}$/;
+function isCurrencyCode(value) {
+	return typeof value === "string" && CANONICAL_CURRENCY_CODE_PATTERN.test(value);
+}
+/** Parse + normalize a currency code, or return null if it isn't a 3-letter code. */
+function parseCurrencyCode(value) {
+	return CURRENCY_CODE_INPUT_PATTERN.test(value) ? value.toUpperCase() : null;
+}
+/**
+* Brand an already-trusted currency code (DB column, generated constant, fixture).
+* Use `parseCurrencyCode` for untrusted boundary values.
+*/
+function unsafeCurrencyCode(value) {
+	return value.toUpperCase();
+}
+const CURRENCY_LOCALE_BY_CODE = {
+	USD: "en-US",
+	GBP: "en-GB",
+	EUR: "de-DE",
+	AUD: "en-AU",
+	CAD: "en-CA",
+	NZD: "en-NZ",
+	JPY: "ja-JP",
+	CNY: "zh-CN",
+	CHF: "de-CH"
+};
+function resolveCurrencyLocale(currencyCode, override) {
+	return override ?? CURRENCY_LOCALE_BY_CODE[currencyCode] ?? "en";
+}
+/**
+* The single currency-amount formatter for the product: minor units in,
+* localized string out.
+*
+* The locale is derived from the currency by default, so output is deterministic
+* across server and client (no SSR/hydration mismatch). All other money
+* formatters in the codebase should delegate here rather than constructing their
+* own `Intl.NumberFormat`.
+*/
+function formatCurrencyAmount(amountCents, currency, options) {
+	const currencyCode = currency.toUpperCase();
+	const locale = resolveCurrencyLocale(currencyCode, options?.locale);
+	try {
+		const exactFormatter = new Intl.NumberFormat(locale, {
+			style: "currency",
+			currency: currencyCode
+		});
+		const fractionDigits = options?.decimals === "auto" ? {
+			minimumFractionDigits: 0,
+			maximumFractionDigits: exactFormatter.resolvedOptions().maximumFractionDigits
+		} : {};
+		return new Intl.NumberFormat(locale, {
+			style: "currency",
+			currency: currencyCode,
+			...fractionDigits
+		}).format(amountCents / 100);
+	} catch {
+		return `${(amountCents / 100).toFixed(2)} ${currencyCode}`;
+	}
+}
+
+//#endregion
+//#region ../core/src/event-pricing.ts
+const EVENT_PRICING_MODES = [
+	"single",
+	"ticket_types",
+	"sliding_scale"
+];
+function isEventPricingMode(value) {
+	return typeof value === "string" && EVENT_PRICING_MODES.includes(value);
+}
+function publicEventPricingDisplay(pricing) {
+	return pricing.display;
+}
+function publicEventPricingType(pricing) {
+	switch (pricing.kind) {
+		case "drop_in":
+		case "free_registration": return "free";
+		case "single_paid":
+		case "ticket_types":
+		case "sliding_scale":
+		case "course": return isFreePublicEventPriceDisplay(pricing.display) ? "free" : "paid";
+		case "external": return "external";
+	}
+}
+function publicEventPricingCurrency(pricing) {
+	switch (pricing.kind) {
+		case "drop_in":
+		case "free_registration":
+		case "single_paid":
+		case "ticket_types":
+		case "sliding_scale": return pricing.currency;
+		case "course": return pricing.display.display.currency;
+		case "external": return null;
+	}
+}
+function publicEventScalarPrice(pricing) {
+	return pricing.kind === "single_paid" ? pricing.amount : null;
+}
+function publicEventPricingMode(pricing) {
+	switch (pricing.kind) {
+		case "single_paid":
+		case "free_registration": return "single";
+		case "ticket_types": return "ticket_types";
+		case "sliding_scale": return "sliding_scale";
+		case "drop_in":
+		case "course":
+		case "external": return undefined;
+	}
+}
+function publicEventTicketTypes(pricing) {
+	return pricing.kind === "ticket_types" ? pricing.ticketTypes : [];
+}
+function isFreePublicEventPriceDisplay(display) {
+	switch (display.kind) {
+		case "free": return true;
+		case "course": return display.display.kind === "free";
+		case "exact":
+		case "from":
+		case "range":
+		case "mixed":
+		case "unavailable":
+		case "external": return false;
+	}
+}
+function formatCoursePriceDisplayLabel(display, options) {
+	switch (display.kind) {
+		case "free":
+		case "unavailable": return "Course";
+		case "exact": return `Course (${formatCurrencyAmount(display.amount, display.currency, options)})`;
+		case "from": return `Course (From ${formatCurrencyAmount(display.amount, display.currency, options)})`;
+		case "range": return `Course (${formatCurrencyAmount(display.minAmount, display.currency, options)} - ${formatCurrencyAmount(display.maxAmount, display.currency, options)})`;
+		default: return assertNever(display);
+	}
+}
+/**
+* The single renderer for a precomputed booking price `display` ADT. This is
+* the one place booking price variants map to user-facing strings — every call
+* site (booking entry, events calendar, event/course details, listings, portal)
+* should route through here so labels never drift. Adding a variant to the ADT
+* breaks compilation here (via `assertNever`) until it is handled.
+*/
+function formatBookingPriceDisplay(display, options = {}) {
+	switch (display.kind) {
+		case "free": return "Free";
+		case "exact": return formatCurrencyAmount(display.amount, display.currency, options);
+		case "from": return `From ${formatCurrencyAmount(display.amount, display.currency, options)}`;
+		case "range": return `${formatCurrencyAmount(display.minAmount, display.currency, options)} - ${formatCurrencyAmount(display.maxAmount, display.currency, options)}`;
+		case "mixed": return display.paidToAmount > display.paidFromAmount ? `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)} - ${formatCurrencyAmount(display.paidToAmount, display.currency, options)}` : `Free / ${formatCurrencyAmount(display.paidFromAmount, display.currency, options)}`;
+		case "unavailable": return "Pricing unavailable";
+		case "external": return display.label;
+		case "course": return formatCoursePriceDisplayLabel(display.display, options);
+		default: return assertNever(display);
+	}
+}
+/** Render an event's price directly from its pricing value. */
+function formatEventPricing(pricing, options = {}) {
+	return formatBookingPriceDisplay(publicEventPricingDisplay(pricing), options);
+}
+
+//#endregion
+//#region ../core/src/event-page-surface-subject.ts
+function createEventSeriesPageSurfaceSubject(eventSeriesId, bookingScope) {
+	return bookingScope === "whole_series" ? {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope,
+		isWholeSeriesBooking: true
+	} : {
+		kind: "eventSeries",
+		eventSeriesId,
+		bookingScope
+	};
+}
+function parseEventPageSurfaceSubject(value) {
+	if (!isRecord$6(value)) return err({ kind: "notObject" });
+	switch (value.kind) {
+		case "eventSeries": {
+			const eventSeriesId = parseEventSeriesId(value.eventSeriesId);
+			if (!eventSeriesId.ok) {
+				return err({
+					kind: "invalidEventSeriesId",
+					error: eventSeriesId.error
+				});
+			}
+			if (value.bookingScope !== "single_occurrence" && value.bookingScope !== "whole_series") {
+				return err({
+					kind: "invalidEventSeriesBookingScope",
+					bookingScope: value.bookingScope
+				});
+			}
+			return ok(createEventSeriesPageSurfaceSubject(eventSeriesId.value, value.bookingScope));
+		}
+		case "eventOffering": {
+			const eventOfferingId = parseEventOfferingId(value.eventOfferingId);
+			if (!eventOfferingId.ok) {
+				return err({
+					kind: "invalidEventOfferingId",
+					error: eventOfferingId.error
+				});
+			}
+			if (!Array.isArray(value.availableEventSeriesIds)) {
+				return err({
+					kind: "unsupportedSubject",
+					subjectKind: value.kind
+				});
+			}
+			const parsedSeriesIds = [];
+			for (const valueId of value.availableEventSeriesIds) {
+				const eventSeriesId = parseEventSeriesId(valueId);
+				if (!eventSeriesId.ok) {
+					return err({
+						kind: "invalidEventSeriesId",
+						error: eventSeriesId.error
+					});
+				}
+				parsedSeriesIds.push(eventSeriesId.value);
+			}
+			return ok({
+				kind: "eventOffering",
+				eventOfferingId: eventOfferingId.value,
+				availableEventSeriesIds: parsedSeriesIds
+			});
+		}
+		default: return err({
+			kind: "unsupportedSubject",
+			subjectKind: value.kind
+		});
+	}
+}
+function toEventPageSurfaceSubjectWire(subject) {
+	return subject;
+}
+function isRecord$6(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region ../core/src/money-input.ts
+function unsafeAsCents(value) {
+	return value;
+}
+function unsafeAsNonNegativeCents(value) {
+	return value;
+}
+function unsafeAsPositiveCents(value) {
+	return value;
+}
+function unwrapCents(value) {
+	return value;
+}
+function isWholeCents(value) {
+	return Number.isFinite(value) && Number.isInteger(value);
+}
+function isNonNegativeWholeCents(value) {
+	return isWholeCents(value) && value >= 0;
+}
+function isPositiveWholeCents(value) {
+	return isWholeCents(value) && value > 0;
+}
+/**
+* Normalizes a derived amount to signed whole cents. Use parse*Cents for
+* untrusted input that should fail instead of truncating or clamping.
+*/
+function toCents(value) {
+	return unsafeAsCents(Math.trunc(value));
+}
+/**
+* Normalizes a derived amount to non-negative whole cents. This intentionally
+* clamps negatives to zero; use parseNonNegativeCents for validation.
+*/
+function toNonNegativeCents(value) {
+	return unsafeAsNonNegativeCents(Math.max(0, Math.trunc(value)));
+}
+function parseCents(value) {
+	if (!Number.isFinite(value)) {
+		return err({ kind: "invalid-number" });
+	}
+	if (!Number.isInteger(value)) {
+		return err({ kind: "not-whole-cents" });
+	}
+	return ok(unsafeAsCents(value));
+}
+function parseNonNegativeCents(value) {
+	const parsed = parseCents(value);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value < 0) {
+		return err({ kind: "negative" });
+	}
+	return ok(unsafeAsNonNegativeCents(parsed.value));
+}
+function parsePositiveCents(value) {
+	const parsed = parseNonNegativeCents(value);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value === 0) {
+		return err({ kind: "zero-not-allowed" });
+	}
+	return ok(unsafeAsPositiveCents(parsed.value));
+}
+function normalizeMoneyInput(value, options) {
+	return (options.stripFormatting === true ? value.replace(/[^0-9.-]/g, "") : value).trim();
+}
+function parseFiniteMoneyAmount(value, options) {
+	const normalized = normalizeMoneyInput(value, options);
+	if (normalized.length === 0) {
+		return err({ kind: "empty" });
+	}
+	const amount = Number(normalized);
+	if (!Number.isFinite(amount)) {
+		return err({ kind: "invalid-number" });
+	}
+	return ok(amount);
+}
+function roundMoneyAmountToCents(amount) {
+	return Math.round(amount * 100);
+}
+function parsePositiveMoneyInputToCents(value, options = {}) {
+	const parsed = parseFiniteMoneyAmount(value, options);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value < 0) {
+		return err({ kind: "negative" });
+	}
+	const amountCents = roundMoneyAmountToCents(parsed.value);
+	if (amountCents <= 0) {
+		return err({ kind: "zero-not-allowed" });
+	}
+	return ok(unsafeAsPositiveCents(amountCents));
+}
+function parseNonNegativeMoneyInputToCents(value, options = {}) {
+	const parsed = parseFiniteMoneyAmount(value, options);
+	if (!parsed.ok) {
+		return parsed;
+	}
+	if (parsed.value < 0) {
+		return err({ kind: "negative" });
+	}
+	return ok(unsafeAsNonNegativeCents(roundMoneyAmountToCents(parsed.value)));
+}
+function parseMoneyInputToCents(value, options = {}) {
+	const parsed = parseFiniteMoneyAmount(value, options);
+	if (!parsed.ok) {
+		return null;
+	}
+	if (options.allowZero === true ? parsed.value < 0 : parsed.value <= 0) {
+		return null;
+	}
+	return roundMoneyAmountToCents(parsed.value);
+}
+function formatMoneyInputFromCents(amountCents) {
+	if (typeof amountCents !== "number" || !Number.isFinite(amountCents)) {
+		return "";
+	}
+	const sign = amountCents < 0 ? "-" : "";
+	const absoluteCents = Math.abs(Math.trunc(amountCents));
+	const units = Math.floor(absoluteCents / 100);
+	const fractional = String(absoluteCents % 100).padStart(2, "0");
+	return `${sign}${units}.${fractional}`;
+}
+
+//#endregion
+//#region ../core/src/booking-flexible-balance.ts
+const DEFAULT_FLEXIBLE_BALANCE_STRIPE_MINIMUM_CHARGE_CENTS = 50;
+function clampFlexibleBalanceConfiguredAmount(amountCents, totalAmountCents) {
+	return Math.max(0, Math.min(amountCents, totalAmountCents));
+}
+function resolveFlexibleBalanceInitialPaymentCents(input) {
+	return clampFlexibleBalanceConfiguredAmount(input.config.upfrontAmountCents, input.totalAmountCents);
+}
+function calculateFlexibleBalanceRemainingBalanceCents(input) {
+	return Math.max(0, input.totalAmountCents - input.paidAmountCents);
+}
+function resolveFlexibleBalanceDueAt(input) {
+	switch (input.dueDateRule.kind) {
+		case "relative_to_start_date": return subtractDaysFromIso(input.bookingStartAt, input.dueDateRule.daysBeforeStart);
+		case "fixed_calendar_date": return input.dueDateRule.dueAt;
+		default: return assertNever$4(input.dueDateRule);
+	}
+}
+function calculateFlexibleBalanceMinimumPaymentCents(input) {
+	if (input.remainingBalanceCents <= 0) {
+		return 0;
+	}
+	const minimumPercentageBps = input.minimumPercentageBps ?? 1e3;
+	const percentageFloor = Math.ceil(input.remainingBalanceCents * minimumPercentageBps / 1e4);
+	return Math.min(input.remainingBalanceCents, Math.max(input.stripeMinimumChargeCents, percentageFloor));
+}
+function resolveFlexibleBalancePaymentEligibility(input) {
+	if (input.remainingBalanceCents <= 0 || input.status === "completed") {
+		return {
+			kind: "unavailable",
+			reason: "already_settled"
+		};
+	}
+	switch (input.status) {
+		case "payment_pending": return {
+			kind: "unavailable",
+			reason: "payment_pending"
+		};
+		case "cancelled_due_to_non_payment": return {
+			kind: "unavailable",
+			reason: "cancelled_due_to_non_payment"
+		};
+		case "refunded": return {
+			kind: "unavailable",
+			reason: "refunded"
+		};
+		case "waived": return {
+			kind: "unavailable",
+			reason: "waived"
+		};
+		case "overdue": return {
+			kind: "full_balance_only",
+			remainingBalanceCents: input.remainingBalanceCents,
+			reason: "overdue"
+		};
+		case "active": {
+			const minimumAmountCents = calculateFlexibleBalanceMinimumPaymentCents({
+				remainingBalanceCents: input.remainingBalanceCents,
+				stripeMinimumChargeCents: input.stripeMinimumChargeCents,
+				minimumPercentageBps: input.minimumPercentageBps
+			});
+			if (minimumAmountCents >= input.remainingBalanceCents) {
+				return {
+					kind: "full_balance_only",
+					remainingBalanceCents: input.remainingBalanceCents,
+					reason: "dust_balance"
+				};
+			}
+			return {
+				kind: "eligible",
+				minimumAmountCents,
+				maximumCustomAmountCents: input.remainingBalanceCents,
+				suggestedPayFullAmountCents: input.remainingBalanceCents
+			};
+		}
+		default: return assertNever$4(input.status);
+	}
+}
+function isFlexibleBalanceReminderSuppressed(input) {
+	const suppressionWindowHours = input.suppressionWindowHours ?? 24;
+	const bookedAtMs = Date.parse(input.bookedAt);
+	const reminderDueAtMs = Date.parse(input.reminderDueAt);
+	if (!Number.isFinite(bookedAtMs) || !Number.isFinite(reminderDueAtMs)) {
+		return false;
+	}
+	return reminderDueAtMs - bookedAtMs < suppressionWindowHours * 60 * 60 * 1e3;
+}
+function buildFlexibleBalanceReminderSchedule(input) {
+	const schedule = [
+		{
+			kind: "due_7_days",
+			scheduledFor: subtractDaysFromIso(input.dueAt, 7)
+		},
+		{
+			kind: "due_1_day",
+			scheduledFor: subtractDaysFromIso(input.dueAt, 1)
+		},
+		{
+			kind: "overdue_1_day",
+			scheduledFor: addDaysToIso(input.dueAt, 1)
+		}
+	];
+	return schedule.map((entry) => ({
+		kind: entry.kind,
+		scheduledFor: entry.scheduledFor,
+		suppressed: isFlexibleBalanceReminderSuppressed({
+			bookedAt: input.bookedAt,
+			reminderDueAt: entry.scheduledFor
+		})
+	}));
+}
+function assertNever$4(value) {
+	throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+//#endregion
+//#region ../core/src/booking-refunds.ts
+function normalizeBookingProtectedDepositPolicyState(value) {
+	return value === "not_applicable" || value === "refundable" || value === "non_refundable" ? value : "not_applicable";
+}
+function shouldAllowProtectedDepositOverride(command) {
+	return command.protectedDepositOverride === "allow_protected_deposit_override";
+}
+function createBookingRefundAmountRequest(amountCents) {
+	return amountCents == null ? { kind: "full_remaining" } : {
+		kind: "partial_amount",
+		amountCents
+	};
+}
+function createOriginalPaymentRefundCommand(options) {
+	const protectedDepositOverride = options.protectedDepositOverride ?? "respect_policy";
+	return options.kind === "refund_and_revoke" ? {
+		kind: "refund_and_revoke",
+		amount: { kind: "full_remaining" },
+		requestedRefundMethod: "original_payment",
+		protectedDepositOverride
+	} : {
+		kind: "refund_only",
+		amount: options.amount ?? { kind: "full_remaining" },
+		requestedRefundMethod: "original_payment",
+		protectedDepositOverride
+	};
+}
+
+//#endregion
+//#region ../core/src/booking-instalments.ts
+function isDepositBearingBookingInstalmentPlan(plan) {
+	switch (plan.kind) {
+		case "deposit_plus_one_remainder":
+		case "deposit_plus_scheduled_instalments": return true;
+		case "equal_scheduled_instalments": return false;
+		default: return assertNever$3(plan);
+	}
+}
+function getBookingInstalmentDepositRefundability(plan) {
+	return isDepositBearingBookingInstalmentPlan(plan) ? plan.depositRefundability : null;
+}
+function getBookingInstalmentProtectedDepositAmountCents(plan) {
+	return isDepositBearingBookingInstalmentPlan(plan) ? plan.depositAmountCents : null;
+}
+function clampConfiguredAmount(amountCents, totalAmountCents) {
+	return Math.max(0, Math.min(amountCents, totalAmountCents));
+}
+function splitAmountWithRemainderInFirst(totalAmountCents, partCount) {
+	if (partCount <= 0) {
+		return [];
+	}
+	const baseAmountCents = Math.floor(totalAmountCents / partCount);
+	const remainderCents = totalAmountCents - baseAmountCents * partCount;
+	return Array.from({ length: partCount }, (_, index) => index === 0 ? baseAmountCents + remainderCents : baseAmountCents);
+}
+function addIntervalPreservingMonthAnchor(isoString, intervalCount, intervalUnit) {
+	const date = new Date(isoString);
+	if (!Number.isFinite(date.getTime())) {
+		return isoString;
+	}
+	switch (intervalUnit) {
+		case "day":
+			date.setUTCDate(date.getUTCDate() + intervalCount);
+			return date.toISOString();
+		case "week":
+			date.setUTCDate(date.getUTCDate() + intervalCount * 7);
+			return date.toISOString();
+		case "month": return addMonthsPreservingAnchorDay(date, intervalCount).toISOString();
+		default: return assertNever$3(intervalUnit);
+	}
+}
+function getBookingInstalmentPlanIntervalCount(plan) {
+	switch (plan.kind) {
+		case "deposit_plus_one_remainder": return plan.remainderDueCount;
+		case "deposit_plus_scheduled_instalments":
+		case "equal_scheduled_instalments": return plan.intervalCount;
+		default: return assertNever$3(plan);
+	}
+}
+function omitZeroAmountFutureRows(rows) {
+	if (rows.length <= 1) {
+		return rows;
+	}
+	const firstRow = rows[0];
+	if (firstRow === undefined) {
+		return [];
+	}
+	const futureRows = rows.slice(1);
+	return [firstRow, ...futureRows.filter((row) => row.amountCents > 0)];
+}
+function formatOrderInstalmentStatusLabel(input) {
+	switch (input.status) {
+		case "pending_initial_payment": return input.phaseKind === "initial" ? "Due today" : "Scheduled";
+		case "scheduled": return "Scheduled";
+		case "paid": return input.phaseKind === "initial" ? "Paid today" : "Paid";
+		case "failed": return "Payment failed";
+		case "waived": return "Waived";
+		case "cancelled": return "Cancelled";
+		case "cancelled_as_paid_early": return "Paid early";
+		case "refunded": return "Refunded";
+		default: return assertNever$3(input.status);
+	}
+}
+const NEXT_DUE_STATUSES = new Set(["scheduled", "failed"]);
+function buildOrderInstalmentSummary(input) {
+	const nextDue = input.instalments.find((instalment) => NEXT_DUE_STATUSES.has(instalment.status)) ?? null;
+	return {
+		status: input.paymentPlan.status,
+		remainingBalanceCents: input.paymentPlan.remainingBalanceCents,
+		nextDueAt: nextDue?.dueAt ?? null,
+		nextDueAmountCents: nextDue?.amountCents ?? null,
+		rows: [...input.instalments]
+	};
+}
+function addMonthsPreservingAnchorDay(date, intervalCount) {
+	const anchorDay = date.getUTCDate();
+	const nextMonth = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + intervalCount, 1, date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()));
+	const lastDayOfTargetMonth = new Date(Date.UTC(nextMonth.getUTCFullYear(), nextMonth.getUTCMonth() + 1, 0)).getUTCDate();
+	nextMonth.setUTCDate(Math.min(anchorDay, lastDayOfTargetMonth));
+	return nextMonth;
+}
+function assertNever$3(value) {
+	throw new Error(`Unexpected value: ${String(value)}`);
+}
+
+//#endregion
+//#region ../core/src/booking-time-zone.ts
+const TIME_ZONE_VALIDITY_CACHE_LIMIT = 100;
+const timeZoneValidityCache = new Map();
+const NUMERIC_OFFSET_TIME_ZONE_PATTERN = /^(?:[+-]\d{2}(?::?\d{2})?|(?:UTC|GMT)[+-]\d{1,2}(?::?\d{2})?)$/iu;
+function isValidBookingTimeZone(timeZone) {
+	const normalized = timeZone.trim();
+	if (NUMERIC_OFFSET_TIME_ZONE_PATTERN.test(normalized)) return false;
+	const cached = timeZoneValidityCache.get(normalized);
+	if (cached !== undefined) return cached;
+	let isValid;
+	try {
+		new Intl.DateTimeFormat("en-US", { timeZone: normalized }).format(new Date());
+		isValid = true;
+	} catch {
+		isValid = false;
+	}
+	if (timeZoneValidityCache.size >= TIME_ZONE_VALIDITY_CACHE_LIMIT) {
+		timeZoneValidityCache.clear();
+	}
+	timeZoneValidityCache.set(normalized, isValid);
+	return isValid;
+}
+function parseBookingTimeZone(timeZone) {
+	if (typeof timeZone !== "string") return err("invalid-time-zone");
+	const normalized = timeZone.trim();
+	if (normalized.length === 0 || NUMERIC_OFFSET_TIME_ZONE_PATTERN.test(normalized) || !isValidBookingTimeZone(normalized)) {
+		return err("invalid-time-zone");
+	}
+	return ok(normalized);
+}
+
+//#endregion
+//#region ../core/src/booking-date-time.ts
+const DEFAULT_LOCALE = "en-US";
+const FALLBACK_TIMEZONE = "UTC";
+const DEFAULT_BOOKING_DATE_TIME_FORMAT = {
+	weekday: "short",
+	month: "short",
+	day: "numeric",
+	hour: "numeric",
+	minute: "2-digit"
+};
+const START_OF_DAY = {
+	hour: 0,
+	minute: 0,
+	second: 0
+};
+const LOCAL_DATE_PATTERN = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/u;
+const DATE_TIME_FORMATTER_CACHE_LIMIT = 100;
+const dateTimeFormatterCache = new Map();
+function getSafeTimeZone(timeZone) {
+	const normalized = typeof timeZone === "string" ? timeZone.trim() : "";
+	return normalized.length > 0 && isValidBookingTimeZone(normalized) ? normalized : FALLBACK_TIMEZONE;
+}
+function parseStrictBookingTimeZone(timeZone) {
+	const parsed = parseBookingTimeZone(timeZone);
+	return parsed.ok ? parsed.value : null;
+}
+function formatParseError(error) {
+	switch (error.reason) {
+		case "invalid_starts_at": return `Expected a valid UTC/offset-aware ISO datetime in startsAt, received "${error.value}"`;
+		case "invalid_ends_at": return `Expected a valid UTC/offset-aware ISO datetime in endsAt, received "${error.value ?? ""}"`;
+		case "invalid_time_zone": return `Expected a valid IANA timezone in timeZone, received "${error.value}"`;
+	}
+}
+function formatToPartsLookup(date, locale, timeZone, format) {
+	return new Map(getCachedDateTimeFormatter(locale, timeZone, format).formatToParts(date).map((part) => [part.type, part.value]));
+}
+function getCachedDateTimeFormatter(locale, timeZone, format) {
+	const formatKey = JSON.stringify(Object.entries(format).sort(([left], [right]) => left.localeCompare(right)));
+	const key = `${locale}\u0000${timeZone}\u0000${formatKey}`;
+	const cached = dateTimeFormatterCache.get(key);
+	if (cached !== undefined) {
+		return cached;
+	}
+	const formatter = new Intl.DateTimeFormat(locale, {
+		...format,
+		timeZone
+	});
+	if (dateTimeFormatterCache.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) {
+		dateTimeFormatterCache.clear();
+	}
+	dateTimeFormatterCache.set(key, formatter);
+	return formatter;
+}
+function getZonedDateTimeParts(date, timeZone) {
+	const parts = formatToPartsLookup(date, "en-GB", timeZone, {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: false
+	});
+	const read = (type) => Number(parts.get(type) ?? "");
+	return {
+		year: read("year"),
+		month: read("month"),
+		day: read("day"),
+		hour: read("hour"),
+		minute: read("minute"),
+		second: read("second")
+	};
+}
+function formatDateKey(date) {
+	const year = String(date.year).padStart(4, "0");
+	const month = String(date.month).padStart(2, "0");
+	const day = String(date.day).padStart(2, "0");
+	return `${year}-${month}-${day}`;
+}
+function toBookingTimeZone(timeZone) {
+	return getSafeTimeZone(timeZone);
+}
+const DEFAULT_BOOKING_TIME_ZONE = FALLBACK_TIMEZONE;
+function resolveBookingTimezone(venueTimezone, siteDefaultTimezone) {
+	return venueTimezone ?? siteDefaultTimezone;
+}
+function resolveBookingTimeZoneId(...candidates) {
+	for (const candidate of candidates) {
+		const normalized = typeof candidate === "string" ? candidate.trim() : "";
+		if (normalized && isValidBookingTimeZone(normalized)) {
+			return normalized;
+		}
+	}
+	return FALLBACK_TIMEZONE;
+}
+function parseUtcIsoDateTimeString(value) {
+	const normalized = value.trim();
+	const hasUtcSuffix = normalized.endsWith("Z");
+	const hasExplicitOffset = /[+-]\d{2}:\d{2}$/u.test(normalized);
+	if (!hasUtcSuffix && !hasExplicitOffset) {
+		return err("missing-timezone-offset");
+	}
+	const date = new Date(normalized);
+	if (Number.isNaN(date.getTime())) {
+		return err("invalid-date-time");
+	}
+	return ok(date.toISOString());
+}
+function toUtcIsoDateTimeString(value) {
+	const parsed = parseUtcIsoDateTimeString(value);
+	if (!parsed.ok) {
+		const message = parsed.error === "missing-timezone-offset" ? `Expected an offset-aware ISO datetime, received "${value}"` : `Expected a valid ISO datetime, received "${value}"`;
+		throw new Error(message);
+	}
+	return parsed.value;
+}
+function parseScheduledBookingDateTime(input) {
+	let startsAt;
+	try {
+		startsAt = toUtcIsoDateTimeString(input.startsAt);
+	} catch {
+		return {
+			ok: false,
+			field: "startsAt",
+			reason: "invalid_starts_at",
+			value: input.startsAt
+		};
+	}
+	const timeZone = parseStrictBookingTimeZone(input.timeZone);
+	if (timeZone === null) {
+		return {
+			ok: false,
+			field: "timeZone",
+			reason: "invalid_time_zone",
+			value: typeof input.timeZone === "string" ? input.timeZone : ""
+		};
+	}
+	return {
+		ok: true,
+		value: {
+			startsAt,
+			timeZone,
+			locale: input.locale
+		}
+	};
+}
+function parseScheduledBookingDateRange(input) {
+	const start = parseScheduledBookingDateTime(input);
+	if (!start.ok) {
+		return start;
+	}
+	if (input.endsAt == null) {
+		return {
+			ok: true,
+			value: start.value
+		};
+	}
+	try {
+		return {
+			ok: true,
+			value: {
+				...start.value,
+				endsAt: toUtcIsoDateTimeString(input.endsAt)
+			}
+		};
+	} catch {
+		return {
+			ok: false,
+			field: "endsAt",
+			reason: "invalid_ends_at",
+			value: input.endsAt
+		};
+	}
+}
+function toScheduledBookingDateTime(input) {
+	const result = parseScheduledBookingDateTime(input);
+	if (result.ok) {
+		return result.value;
+	}
+	throw new Error(formatParseError(result));
+}
+function toScheduledBookingDateRange(input) {
+	const result = parseScheduledBookingDateRange(input);
+	if (result.ok) {
+		return result.value;
+	}
+	throw new Error(formatParseError(result));
+}
+function formatBookingInstant(isoString, options) {
+	const date = new Date(isoString);
+	if (Number.isNaN(date.getTime())) {
+		return isoString;
+	}
+	return getCachedDateTimeFormatter(options.locale ?? DEFAULT_LOCALE, getSafeTimeZone(options.timeZone), options.format).format(date);
+}
+function formatBookingDate(input, format = {
+	weekday: "long",
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+}) {
+	return formatBookingInstant(input.startsAt, {
+		locale: input.locale,
+		timeZone: input.timeZone,
+		format
+	});
+}
+function formatBookingTime(input, format = {
+	hour: "numeric",
+	minute: "2-digit",
+	hour12: true
+}) {
+	return formatBookingInstant(input.startsAt, {
+		locale: input.locale,
+		timeZone: input.timeZone,
+		format
+	});
+}
+/**
+* Formats the compact English event-time presentation used by public surfaces.
+*
+* This intentionally owns the lowercase day-period token and zero-minute
+* omission instead of depending on locale-specific spacing or punctuation.
+* Callers must only use it for an English presentation contract.
+*/
+function formatBookingCompactEnglishTime(input) {
+	const date = new Date(input.startsAt);
+	if (Number.isNaN(date.getTime())) {
+		return input.startsAt;
+	}
+	const parts = formatToPartsLookup(date, input.locale ?? "en-GB", input.timeZone, {
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true
+	});
+	const hour = parts.get("hour");
+	const minute = parts.get("minute");
+	const dayPeriod = parts.get("dayPeriod");
+	if (hour === undefined || minute === undefined || dayPeriod === undefined) {
+		return input.startsAt;
+	}
+	const clock = minute === "00" ? hour : `${hour}:${minute}`;
+	return `${clock}${dayPeriod.toLowerCase()}`;
+}
+function formatBookingDateTime(input, format = DEFAULT_BOOKING_DATE_TIME_FORMAT) {
+	if (format === DEFAULT_BOOKING_DATE_TIME_FORMAT) {
+		return `${formatBookingDate(input, {
+			weekday: "short",
+			month: "short",
+			day: "numeric"
+		})}, ${formatBookingTime(input)}`;
+	}
+	return formatBookingInstant(input.startsAt, {
+		locale: input.locale,
+		timeZone: input.timeZone,
+		format
+	});
+}
+function formatBookingDateParts(input, options) {
+	return {
+		date: formatBookingDate(input, options?.dateFormat ?? {
+			weekday: "short",
+			month: "short",
+			day: "numeric",
+			year: "numeric"
+		}),
+		time: formatBookingTime(input, options?.timeFormat ?? {
+			hour: "numeric",
+			minute: "2-digit",
+			hour12: true
+		})
+	};
+}
+function getBookingLocalDateKey(input) {
+	return formatDateKey(getLocalScheduleDate(new Date(input.startsAt), input.timeZone));
+}
+function compareLocalScheduleDates(left, right) {
+	return Date.UTC(left.year, left.month - 1, left.day) - Date.UTC(right.year, right.month - 1, right.day);
+}
+function parseBookingLocalDate(value) {
+	const match = LOCAL_DATE_PATTERN.exec(value.trim());
+	if (match === null || match.groups === undefined) {
+		throw new Error(`Invalid booking date format: "${value}" (expected YYYY-MM-DD)`);
+	}
+	const year = Number(match.groups.year);
+	const month = Number(match.groups.month);
+	const day = Number(match.groups.day);
+	const candidate = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
+	if (Number.isNaN(candidate.getTime()) || candidate.getUTCFullYear() !== year || candidate.getUTCMonth() + 1 !== month || candidate.getUTCDate() !== day) {
+		throw new Error(`Invalid booking date format: "${value}" (expected YYYY-MM-DD)`);
+	}
+	return {
+		year,
+		month,
+		day
+	};
+}
+function parseBookingUtcDateWindow(input) {
+	const timeZone = resolveBookingTimeZoneId(input.timeZone);
+	let startLocalDate;
+	try {
+		startLocalDate = parseBookingLocalDate(input.startDate);
+	} catch {
+		return {
+			ok: false,
+			field: "startDate",
+			reason: "invalid_date_format",
+			value: input.startDate
+		};
+	}
+	let endLocalDate;
+	try {
+		endLocalDate = parseBookingLocalDate(input.endDate);
+	} catch {
+		return {
+			ok: false,
+			field: "endDate",
+			reason: "invalid_date_format",
+			value: input.endDate
+		};
+	}
+	if (compareLocalScheduleDates(startLocalDate, endLocalDate) > 0) {
+		return {
+			ok: false,
+			field: "endDate",
+			reason: "invalid_date_range",
+			value: input.endDate
+		};
+	}
+	return {
+		ok: true,
+		value: {
+			timeZone,
+			startLocalDate,
+			endLocalDate,
+			startAt: localScheduleDateTimeToUtcDate(startLocalDate, START_OF_DAY, timeZone),
+			endExclusive: localScheduleDateTimeToUtcDate(addLocalScheduleDays(endLocalDate, 1), START_OF_DAY, timeZone)
+		}
+	};
+}
+function buildBookingUtcDateWindow(input) {
+	const result = parseBookingUtcDateWindow(input);
+	if (result.ok) {
+		return result.value;
+	}
+	if (result.reason === "invalid_date_range") {
+		throw new Error(`Invalid booking date range: startDate "${input.startDate}" must be on or before endDate "${input.endDate}"`);
+	}
+	throw new Error(`Invalid booking date format: "${result.value}" (expected YYYY-MM-DD)`);
+}
+function formatBookingRange(input, options) {
+	if (input.endsAt == null) {
+		const parts = formatBookingDateParts(input, options);
+		return `${parts.date}, ${parts.time}`;
+	}
+	const startKey = getBookingLocalDateKey(input);
+	const endDateTime = toScheduledBookingDateTime({
+		startsAt: input.endsAt,
+		timeZone: input.timeZone,
+		locale: input.locale
+	});
+	const endKey = getBookingLocalDateKey(endDateTime);
+	const startDate = formatBookingDate(input, options?.dateFormat ?? {
+		month: "short",
+		day: "numeric",
+		year: "numeric"
+	});
+	const startTime = formatBookingTime(input, options?.timeFormat);
+	const endTime = formatBookingTime(endDateTime, options?.timeFormat);
+	if (startKey === endKey) {
+		return `${startDate}, ${startTime} - ${endTime}`;
+	}
+	const endDate = formatBookingDate(endDateTime, options?.dateFormat ?? {
+		month: "short",
+		day: "numeric",
+		year: "numeric"
+	});
+	return `${startDate}, ${startTime} - ${endDate}, ${endTime}`;
+}
+function parseLocalScheduleTime(value) {
+	const match = /^(?<hour>\d{1,2}):(?<minute>\d{2})(?::(?<second>\d{2}))?$/u.exec(value.trim());
+	if (match === null || match.groups === undefined) {
+		throw new Error(`Invalid start time format: "${value}" (expected HH:MM or HH:MM:SS)`);
+	}
+	const hour = Number(match.groups.hour);
+	const minute = Number(match.groups.minute);
+	const second = match.groups.second !== undefined ? Number(match.groups.second) : 0;
+	if (Number.isNaN(hour) || Number.isNaN(minute) || Number.isNaN(second) || hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 59) {
+		throw new Error(`Invalid start time format: "${value}" (expected HH:MM or HH:MM:SS)`);
+	}
+	return {
+		hour,
+		minute,
+		second
+	};
+}
+function getLocalScheduleDate(date, timeZone) {
+	const parts = getZonedDateTimeParts(date, getSafeTimeZone(timeZone));
+	return {
+		year: parts.year,
+		month: parts.month,
+		day: parts.day
+	};
+}
+function getLocalScheduleTime(date, timeZone) {
+	const parts = getZonedDateTimeParts(date, getSafeTimeZone(timeZone));
+	return {
+		hour: parts.hour,
+		minute: parts.minute,
+		second: parts.second
+	};
+}
+function formatLocalScheduleDate(date) {
+	return formatDateKey(date);
+}
+function formatLocalScheduleTime(time) {
+	return `${String(time.hour).padStart(2, "0")}:${String(time.minute).padStart(2, "0")}`;
+}
+function getDaysInLocalMonth(year, month) {
+	return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+function addLocalScheduleDays(date, days) {
+	const utcDate = new Date(Date.UTC(date.year, date.month - 1, date.day + days, 12, 0, 0));
+	return {
+		year: utcDate.getUTCFullYear(),
+		month: utcDate.getUTCMonth() + 1,
+		day: utcDate.getUTCDate()
+	};
+}
+function addLocalScheduleMonths(date, months) {
+	const targetMonthIndex = date.month - 1 + months;
+	const base = new Date(Date.UTC(date.year, targetMonthIndex, 1, 12, 0, 0));
+	const year = base.getUTCFullYear();
+	const month = base.getUTCMonth() + 1;
+	const day = Math.min(date.day, getDaysInLocalMonth(year, month));
+	return {
+		year,
+		month,
+		day
+	};
+}
+function getLocalScheduleDayOfWeek(date) {
+	return new Date(Date.UTC(date.year, date.month - 1, date.day, 12, 0, 0)).getUTCDay();
+}
+function localScheduleDateTimeToUtcDate(localDate, localTime, timeZone) {
+	const resolvedTimeZone = getSafeTimeZone(timeZone);
+	const targetLocalMs = Date.UTC(localDate.year, localDate.month - 1, localDate.day, localTime.hour, localTime.minute, localTime.second, 0);
+	let guess = targetLocalMs;
+	const seenGuesses = new Set();
+	for (let iteration = 0; iteration < 4; iteration += 1) {
+		seenGuesses.add(guess);
+		const actual = getZonedDateTimeParts(new Date(guess), resolvedTimeZone);
+		const actualLocalMs = Date.UTC(actual.year, actual.month - 1, actual.day, actual.hour, actual.minute, actual.second, 0);
+		const diff = actualLocalMs - targetLocalMs;
+		if (diff === 0) {
+			return new Date(guess);
+		}
+		const nextGuess = guess - diff;
+		if (seenGuesses.has(nextGuess)) {
+			return new Date(Math.max(guess, nextGuess));
+		}
+		guess = nextGuess;
+	}
+	return new Date(guess);
+}
+
+//#endregion
+//#region ../core/src/dated-offering-settlement.ts
+function parseStripeReference(value) {
+	if (typeof value !== "string") return err({ kind: "not_string" });
+	const normalized = value.trim();
+	return normalized.length === 0 ? err({ kind: "empty_string" }) : ok(normalized);
+}
+const parseStripePaymentIntentRef = (value) => parseStripeReference(value);
+const parseStripeWebhookEventRef = (value) => parseStripeReference(value);
+const parseStripeBalanceTransactionRef = (value) => parseStripeReference(value);
+const parseStripeChargeRef = (value) => parseStripeReference(value);
+const parseStripeAccountRef = (value) => parseStripeReference(value);
+const parseStripeCheckoutSessionId = (value) => parseStripeReference(value);
+
+//#endregion
+//#region ../core/src/person-records.ts
+const RECORD_ENTRY_KINDS = [
+	"person_note",
+	"prep_note",
+	"session_note",
+	"follow_up_note",
+	"booking_questions_snapshot",
+	"correction_note"
+];
+const PERSON_RECORD_NOTE_KINDS = [
+	"person_note",
+	"prep_note",
+	"session_note",
+	"follow_up_note",
+	"correction_note"
+];
+function parseRecordEntryKind(value) {
+	return RECORD_ENTRY_KINDS.includes(value) ? ok(value) : err({
+		kind: "unsupported_record_entry_kind",
+		value
+	});
+}
+
+//#endregion
+//#region ../core/src/rectification.ts
+const RECTIFICATION_SURFACES = [
+	"customer_profile",
+	"booking_identity",
+	"event_registration_identity",
+	"course_enrollment_identity",
+	"person_record_entry",
+	"booking_question_snapshot",
+	"form_submission",
+	"newsletter_subscriber",
+	"order_financial_record",
+	"audit_event",
+	"derived_history_ledger"
+];
+const RECTIFICATION_ISSUE_URL_BASE = "https://github.com/wubss/builder/issues";
+const RECTIFICATION_IDENTITY_BOUNDARIES = {
+	customer_commercial_current_identity: { kind: "customer_commercial_current_identity" },
+	customer_backed_participant_current_identity: { kind: "customer_backed_participant_current_identity" },
+	person_record_current_note: { kind: "person_record_current_note" },
+	immutable_subject_snapshot: { kind: "immutable_subject_snapshot" },
+	newsletter_current_subscription_identity: { kind: "newsletter_current_subscription_identity" },
+	finance_integrity_record: { kind: "finance_integrity_record" },
+	immutable_audit_history: { kind: "immutable_audit_history" },
+	derived_history_projection_or_ledger: { kind: "derived_history_projection_or_ledger" }
+};
+const RECTIFICATION_HISTORY_PROPAGATION_PLANS = {
+	update_current_identity_only: { kind: "update_current_identity_only" },
+	append_correction_note: { kind: "append_correction_note" },
+	annotate_immutable_snapshot: { kind: "annotate_immutable_snapshot" },
+	manual_review_required: { kind: "manual_review_required" },
+	blocked_immutable_history: { kind: "blocked_immutable_history" }
+};
+
+//#endregion
+//#region ../core/src/location.ts
+function normalizeLocationAddressText(value) {
+	if (typeof value !== "string") {
+		return null;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function hasLocationCoordinates(value) {
+	return value != null && typeof value.lat === "number" && typeof value.lng === "number";
+}
+function toLocationCoordinates(value) {
+	if (!hasLocationCoordinates(value)) {
+		return null;
+	}
+	return {
+		lat: value.lat,
+		lng: value.lng
+	};
+}
+
+//#endregion
+//#region ../core/src/string.ts
+/**
+* String utilities
+*/
+/**
+* Return the string value when the input is already a string, otherwise null.
+*/
+function asNullableString(value) {
+	return typeof value === "string" ? value : null;
+}
+/**
+* Return a non-empty string value, otherwise null.
+*/
+function asNonEmptyStringOrNull(value) {
+	return typeof value === "string" && value.length > 0 ? value : null;
+}
+/**
+* Narrow nullable values to the present value.
+*/
+function isPresent(value) {
+	return value !== null && value !== undefined;
+}
+/**
+* Return true for string values that contain at least one character.
+*/
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+/**
+* Narrow optional string values to non-empty strings.
+*/
+function hasText(value) {
+	return isNonEmptyString(value);
+}
+/**
+* Trim a user-entered string and collapse blank values to null.
+*/
+function trimmedStringOrNull(value) {
+	const trimmed = typeof value === "string" ? value.trim() : "";
+	return trimmed.length > 0 ? trimmed : null;
+}
+/**
+* Capitalize the first character of a string
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+//#region ../core/src/business-address.ts
+function normalizeCountryCode(value) {
+	const trimmed = trimmedStringOrNull(value);
+	return trimmed !== null ? trimmed.toUpperCase() : null;
+}
+function normalizeCoordinate(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function isLatitude(value) {
+	return value >= -90 && value <= 90;
+}
+function isLongitude(value) {
+	return value >= -180 && value <= 180;
+}
+function buildBusinessAddressDisplayText(input) {
+	const displayText = [
+		trimmedStringOrNull(input.addressLine1),
+		trimmedStringOrNull(input.addressLine2),
+		trimmedStringOrNull(input.locality),
+		trimmedStringOrNull(input.region),
+		trimmedStringOrNull(input.postalCode),
+		normalizeCountryCode(input.countryCode)
+	].filter((part) => part !== null).join(", ");
+	return displayText.length > 0 ? displayText : null;
+}
+function validateBusinessAddressDraft(input) {
+	const addressLine1 = trimmedStringOrNull(input.addressLine1);
+	const addressLine2 = trimmedStringOrNull(input.addressLine2);
+	const locality = trimmedStringOrNull(input.locality);
+	const region = trimmedStringOrNull(input.region);
+	const postalCode = trimmedStringOrNull(input.postalCode);
+	const countryCode = normalizeCountryCode(input.countryCode);
+	const displayAddress = trimmedStringOrNull(input.displayAddress) ?? buildBusinessAddressDisplayText(input);
+	const lat = normalizeCoordinate(input.lat);
+	const lng = normalizeCoordinate(input.lng);
+	const errors = [];
+	if (addressLine1 === null) errors.push("missing_address_line_1");
+	if (locality === null) errors.push("missing_locality");
+	if (countryCode === null) errors.push("missing_country_code");
+	if (displayAddress === null) errors.push("missing_display_address");
+	if (lat === null) errors.push("missing_latitude");
+	else if (!isLatitude(lat)) errors.push("invalid_latitude");
+	if (lng === null) errors.push("missing_longitude");
+	else if (!isLongitude(lng)) errors.push("invalid_longitude");
+	if (errors.length > 0 || addressLine1 === null || locality === null || countryCode === null || displayAddress === null || lat === null || lng === null) {
+		return {
+			success: false,
+			errors
+		};
+	}
+	return {
+		success: true,
+		address: {
+			addressLine1,
+			addressLine2,
+			locality,
+			region,
+			postalCode,
+			countryCode,
+			displayAddress,
+			lat,
+			lng
+		}
+	};
+}
+function isCompleteBusinessAddress(value) {
+	if (value == null) return false;
+	return validateBusinessAddressDraft(value).success;
+}
+function businessAddressToAddressedLocation(address) {
+	if (address == null) return null;
+	return {
+		addressText: address.displayAddress,
+		lat: address.lat,
+		lng: address.lng
+	};
+}
+
+//#endregion
+//#region ../core/src/try-async.ts
+async function tryAsync(run, toError) {
+	try {
+		return ok(await run());
+	} catch (error) {
+		return err(toError(error));
+	}
+}
+
+//#endregion
+//#region ../core/src/narrow-result.ts
+/** Unwrap a NarrowResult, throwing on failure. Use at persistence boundaries. */
+function unwrapNarrow(result) {
+	if (!result.ok) throw new Error(result.error);
+	return result.value;
+}
+
+//#endregion
+//#region ../core/src/non-empty-array.ts
+function fromArray(items) {
+	const [first, ...rest] = items;
+	if (first === undefined) {
+		return err("empty_array");
+	}
+	return ok([first, ...rest]);
+}
+function mapNonEmptyArray(items, map) {
+	return items.map(map);
+}
+
+//#endregion
+//#region ../core/src/editor-state.ts
+const unsafeAsEditorSiteId = (value) => value;
+const unsafeAsEditorPageId = (value) => value;
+const unsafeAsEditorEntryId = (value) => value;
+const unsafeAsEditorBlockId = (value) => value;
+const unsafeAsEditorMetadataValues = (value) => value;
+const unsafeAsEditorContentValues = (value) => value;
+const unsafeAsEditorBlockValues = (value) => value;
+function createEditorInsertBlockCommand(block, draft, index) {
+	return {
+		type: "insert-block",
+		block,
+		draft,
+		index
+	};
+}
+function createEditorRemoveBlockCommand(blockId) {
+	return {
+		type: "remove-block",
+		blockId
+	};
+}
+function createEditorReorderBlocksCommand(blockIds) {
+	return {
+		type: "reorder-blocks",
+		blockIds
+	};
+}
+
+//#endregion
+//#region ../core/src/sensitive-collection.ts
+const SENSITIVE_COLLECTION_MODES = ["standard", "sensitive"];
+const SENSITIVE_COLLECTION_SURFACES = ["form", "booking_questions"];
+const SENSITIVE_COLLECTION_AUDIT_TARGET_TYPES = [
+	"form",
+	"appointment_service",
+	"event_series",
+	"course"
+];
+const SENSITIVE_DOWNSTREAM_CHANNELS = [
+	"owner_notification_email",
+	"customer_auto_reply",
+	"webhook_payload",
+	"webhook_delivery_log",
+	"csv_export",
+	"dashboard_submission_view",
+	"dsar_export",
+	"protected_record_snapshot",
+	"audit_metadata"
+];
+const SENSITIVE_COLLECTION_CONFIRMATION_VERSION = 1;
+const SENSITIVE_COLLECTION_CONFIRMATION_COPY = [
+	"I understand this form may collect sensitive client information.",
+	"I understand Riverbank will restrict emails, webhooks, exports, and logs for these answers.",
+	"I understand existing external copies made before enabling this setting cannot be automatically recalled."
+];
+const SENSITIVE_SUBMISSION_DASHBOARD_REMINDER_COPY = "This submission is marked sensitive. Only use or share these answers where necessary, and avoid copying them into emails or external systems unless you have a clear reason.";
+const SENSITIVE_SUBMISSION_DETAIL_REMINDER_COPY = "This submission is marked sensitive. Keep answers inside Riverbank unless there is a clear reason to copy them elsewhere.";
+const SENSITIVE_METADATA_ONLY_PAYLOAD_KEYS = [
+	"submissionId",
+	"siteId",
+	"surfaceId",
+	"surfaceTitle",
+	"submittedAt",
+	"dashboardUrl",
+	"sensitiveCollectionMode"
+];
+const STANDARD_SENSITIVE_COLLECTION_CONFIG = {
+	mode: "standard",
+	enabledAt: null,
+	enabledByUserId: null,
+	confirmationVersion: null
+};
+function parseSensitiveCollectionMode(value) {
+	return value === "standard" || value === "sensitive" ? value : null;
+}
+function parseSensitiveCollectionConfirmationVersion(value) {
+	return value === SENSITIVE_COLLECTION_CONFIRMATION_VERSION ? SENSITIVE_COLLECTION_CONFIRMATION_VERSION : null;
+}
+function isSensitiveCollectionAdminRole(actorRole) {
+	return actorRole === "site_owner" || actorRole === "site_admin";
+}
+function deriveEffectiveSensitiveCollectionMode(input) {
+	return input.snapshotMode === "sensitive" || input.currentMode === "sensitive" ? "sensitive" : "standard";
+}
+function planSensitiveCollectionConfigChange(input) {
+	const { current, requested, actorRole, siteProfile } = input;
+	if (current.mode === "sensitive" && requested.mode === "sensitive") {
+		return siteProfile === "sensitive_client_records" ? {
+			kind: "noop_already_sensitive",
+			current
+		} : {
+			kind: "noop_already_sensitive_grandfathered",
+			current
+		};
+	}
+	if (current.mode === "standard" && requested.mode === "standard") {
+		return {
+			kind: "noop_standard",
+			current
+		};
+	}
+	if (!isSensitiveCollectionAdminRole(actorRole)) {
+		return { kind: "denied_actor_not_admin" };
+	}
+	if (requested.mode === "standard") {
+		return {
+			kind: "allowed_disable",
+			next: STANDARD_SENSITIVE_COLLECTION_CONFIG
+		};
+	}
+	if (siteProfile !== "sensitive_client_records") {
+		return { kind: "denied_site_profile_not_enabled" };
+	}
+	if (requested.confirmationVersion !== SENSITIVE_COLLECTION_CONFIRMATION_VERSION) {
+		return {
+			kind: "invalid_confirmation_version",
+			expectedVersion: SENSITIVE_COLLECTION_CONFIRMATION_VERSION
+		};
+	}
+	return {
+		kind: "allowed_enable",
+		next: {
+			mode: "sensitive",
+			enabledAt: input.nowIso,
+			enabledByUserId: input.actorUserId,
+			confirmationVersion: requested.confirmationVersion
+		}
+	};
+}
+function planSensitiveSubmissionTreatment(input) {
+	const { mode, channel } = input;
+	if (mode === "standard") {
+		return {
+			kind: "standard_payload",
+			channel
+		};
+	}
+	switch (channel) {
+		case "owner_notification_email":
+		case "webhook_payload":
+		case "webhook_delivery_log":
+		case "audit_metadata": return {
+			kind: "metadata_only",
+			channel
+		};
+		case "customer_auto_reply": return {
+			kind: "no_answer_echo",
+			channel
+		};
+		case "csv_export": return {
+			kind: "restricted_or_redacted",
+			channel
+		};
+		case "dashboard_submission_view": return {
+			kind: "authorized_with_reminder",
+			channel
+		};
+		case "dsar_export": return {
+			kind: "include_marked_sensitive",
+			channel
+		};
+		case "protected_record_snapshot": return {
+			kind: "protected_storage_required",
+			channel
+		};
+		default: return assertNever$2(channel);
+	}
+}
+function assertNever$2(value) {
+	throw new Error(`Unhandled sensitive collection case: ${String(value)}`);
+}
+
+//#endregion
+//#region ../core/src/participants.ts
+function unsafeAsParticipantEmail(value) {
+	return value;
+}
+function unsafeAsParticipantSlotKey(value) {
+	return value;
+}
+function unsafeAsParticipantCount(value) {
+	return value;
+}
+function unsafeAsParticipantDisplayLabel(value) {
+	return value;
+}
+/**
+* Canonicalizes an optional participant email for equality checks.
+*
+* This intentionally does not validate email shape; call parseParticipantEmail at
+* API/DB boundaries that require a syntactically usable address.
+*/
+function normalizeParticipantEmail(value) {
+	const normalized = value?.trim().normalize("NFC").toLowerCase() ?? "";
+	return normalized.length > 0 ? unsafeAsParticipantEmail(normalized) : null;
+}
+function parseParticipantEmail(value) {
+	const normalized = normalizeParticipantEmail(value);
+	if (normalized === null) {
+		return err({ kind: "empty_email" });
+	}
+	if (!isEmailLike(normalized)) {
+		return err({ kind: "invalid_email_shape" });
+	}
+	return ok(normalized);
+}
+function parseParticipantCount(value) {
+	if (!Number.isInteger(value)) {
+		return err({ kind: "non_integer_participant_count" });
+	}
+	if (value <= 0) {
+		return err({ kind: "non_positive_participant_count" });
+	}
+	return ok(unsafeAsParticipantCount(value));
+}
+function provisionalEventGuestParticipantIdentity(input) {
+	return {
+		kind: "event_guest",
+		eventAttendeeGuestId: input.eventAttendeeGuestId,
+		slotKey: input.slotKey
+	};
+}
+const provisionalParticipantIdentityEncoders = { event_guest: (identity) => ({
+	kind: identity.kind,
+	source: "event_guest_backfill",
+	eventAttendeeGuestId: identity.eventAttendeeGuestId,
+	slotKey: identity.slotKey
+}) };
+function encodeProvisionalParticipantIdentity(identity) {
+	return provisionalParticipantIdentityEncoders[identity.kind](identity);
+}
+function parseProvisionalParticipantIdentity(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return err({ kind: "not_an_object" });
+	}
+	const metadata = value;
+	const kind = metadata.kind ?? metadata.source;
+	if (kind !== "event_guest" && kind !== "event_guest_backfill") {
+		return err({ kind: "unsupported_identity_kind" });
+	}
+	if (typeof metadata.eventAttendeeGuestId !== "string") {
+		return err({ kind: "missing_event_attendee_guest_id" });
+	}
+	if (typeof metadata.slotKey !== "string") {
+		return err({ kind: "missing_slot_key" });
+	}
+	return ok(provisionalEventGuestParticipantIdentity({
+		eventAttendeeGuestId: unsafeAsEventAttendeeGuestId(metadata.eventAttendeeGuestId),
+		slotKey: unsafeAsParticipantSlotKey(metadata.slotKey)
+	}));
+}
+function deriveParticipantDisplayLabel(input) {
+	const displayName = trimmedStringOrNull(input.displayName);
+	if (displayName !== null) {
+		return unsafeAsParticipantDisplayLabel(displayName);
+	}
+	if (input.emailNormalized !== null) {
+		return unsafeAsParticipantDisplayLabel(input.emailNormalized);
+	}
+	return unsafeAsParticipantDisplayLabel("Participant");
+}
+function participantIdentityStateToContactFields(identityState) {
+	switch (identityState.kind) {
+		case "booker_supplied": return {
+			identityState: "booker_supplied",
+			email: null
+		};
+		case "contactable":
+		case "portal_claimed": return {
+			identityState: identityState.kind,
+			email: identityState.email
+		};
+		case "staff_verified": return {
+			identityState: "staff_verified",
+			email: identityState.email
+		};
+	}
+}
+function resolveParticipantSelfServiceEligibility(input) {
+	if (input.identityState.kind === "booker_supplied") {
+		return { kind: "blocked_staff_managed_only" };
+	}
+	const email = input.identityState.email;
+	if (email === null || input.participantId === null) {
+		return { kind: "blocked_missing_email" };
+	}
+	return {
+		kind: "eligible",
+		participantId: input.participantId,
+		email
+	};
+}
+function projectAppointmentParticipantSlot(input) {
+	return buildSlot({
+		slotKey: unsafeAsParticipantSlotKey(`appointment:${input.appointmentId}`),
+		contact: input.customer,
+		participation: {
+			kind: "appointment",
+			appointmentId: input.appointmentId
+		}
+	});
+}
+function projectCourseEnrollmentParticipantSlot(input) {
+	return buildSlot({
+		slotKey: unsafeAsParticipantSlotKey(`course_enrollment:${input.enrollmentId}`),
+		contact: input.customer,
+		participation: {
+			kind: "course_enrollment",
+			enrollmentId: input.enrollmentId
+		}
+	});
+}
+function projectSingleSubjectParticipantRoster(input) {
+	const slot = projectSingleSubjectParticipantSlot(input);
+	return {
+		slots: [slot],
+		issues: reconcileParticipantRoster({
+			expectedCount: unsafeAsParticipantCount(1),
+			slots: [slot]
+		})
+	};
+}
+function buildSingleSubjectParticipantPersistenceIntent(input) {
+	const slot = projectSingleSubjectParticipantSlot(input);
+	const base = {
+		customerId: input.customer.customerId,
+		displayName: slot.displayName,
+		phone: slot.phone,
+		participation: slot.participation
+	};
+	if (slot.email === null) {
+		return {
+			kind: "provisional_single_subject_participant",
+			...base
+		};
+	}
+	return {
+		kind: "participant_subject",
+		...base,
+		email: slot.email
+	};
+}
+function projectSingleSubjectParticipantSlot(input) {
+	switch (input.target.kind) {
+		case "appointment": return projectAppointmentParticipantSlot({
+			appointmentId: input.target.appointmentId,
+			customer: input.customer
+		});
+		case "course_enrollment": return projectCourseEnrollmentParticipantSlot({
+			enrollmentId: input.target.enrollmentId,
+			customer: input.customer
+		});
+		default: return assertNever$1(input.target);
+	}
+}
+function projectCourseSessionAttendanceParticipantSlot(input) {
+	return {
+		slotKey: unsafeAsParticipantSlotKey(`course_session_attendance:${input.attendeeId}`),
+		participation: {
+			kind: "course_session_attendance",
+			attendeeId: input.attendeeId,
+			enrollmentId: input.enrollmentId
+		}
+	};
+}
+function projectEventRegistrationParticipantRoster(input) {
+	const bookerSlot = buildSlot({
+		slotKey: unsafeAsParticipantSlotKey(`event_registration_booker:${input.attendeeId}`),
+		contact: input.booker,
+		participation: {
+			kind: "event_registration_booker",
+			attendeeId: input.attendeeId
+		}
+	});
+	const guestSlots = input.guests.map((guest) => buildSlot({
+		slotKey: unsafeAsParticipantSlotKey(`event_guest:${guest.guestId}`),
+		contact: guest,
+		participation: {
+			kind: "event_guest",
+			attendeeId: input.attendeeId,
+			guestId: guest.guestId
+		}
+	}));
+	const slots = [bookerSlot, ...guestSlots];
+	return {
+		slots,
+		issues: reconcileParticipantRoster({
+			expectedCount: input.ticketsCount,
+			slots
+		})
+	};
+}
+function reconcileParticipantRoster(input) {
+	const issues = [];
+	if (input.slots.length < input.expectedCount) {
+		issues.push({
+			kind: "participant_count_below_ticket_count",
+			expectedCount: input.expectedCount,
+			actualCount: input.slots.length
+		});
+	}
+	if (input.slots.length > input.expectedCount) {
+		issues.push({
+			kind: "participant_count_above_ticket_count",
+			expectedCount: input.expectedCount,
+			actualCount: input.slots.length
+		});
+	}
+	issues.push(...findDuplicateParticipantEmails(input.slots));
+	return issues;
+}
+function planParticipantSubjectResolution(input) {
+	const existingParticipantIdByEmail = new Map(input.existingParticipantsByEmail.map((participant) => [participant.email, participant.participantId]));
+	const duplicateSlotKeysByEmail = new Map(input.projection.issues.filter((issue) => issue.kind === "duplicate_email_in_booking_context").map((issue) => [issue.email, issue.slotKeys]));
+	return input.projection.slots.map((slot) => {
+		if (slot.email === null) {
+			return {
+				kind: "staff_managed_slot",
+				slotKey: slot.slotKey
+			};
+		}
+		const duplicateSlotKeys = duplicateSlotKeysByEmail.get(slot.email);
+		if (duplicateSlotKeys !== undefined) {
+			return {
+				kind: "blocked_duplicate_participant_in_booking",
+				slotKey: slot.slotKey,
+				email: slot.email,
+				conflictingSlotKeys: duplicateSlotKeys
+			};
+		}
+		const participantId = existingParticipantIdByEmail.get(slot.email);
+		if (participantId !== undefined) {
+			return {
+				kind: "reuse_participant_by_site_email",
+				slotKey: slot.slotKey,
+				email: slot.email,
+				participantId
+			};
+		}
+		return {
+			kind: "create_participant",
+			slotKey: slot.slotKey,
+			email: slot.email,
+			displayName: slot.displayName,
+			phone: slot.phone
+		};
+	});
+}
+function buildSlot(input) {
+	const email = normalizeParticipantEmail(input.contact.email);
+	return {
+		slotKey: input.slotKey,
+		displayName: trimmedStringOrNull(input.contact.name),
+		email,
+		phone: trimmedStringOrNull(input.contact.phone),
+		identityState: email === null ? { kind: "booker_supplied" } : {
+			kind: "contactable",
+			email
+		},
+		participation: input.participation
+	};
+}
+function findDuplicateParticipantEmails(slots) {
+	const slotKeysByEmail = new Map();
+	for (const slot of slots) {
+		if (slot.email === null) {
+			continue;
+		}
+		const existing = slotKeysByEmail.get(slot.email) ?? [];
+		existing.push(slot.slotKey);
+		slotKeysByEmail.set(slot.email, existing);
+	}
+	return [...slotKeysByEmail.entries()].filter(([, slotKeys]) => slotKeys.length > 1).map(([email, slotKeys]) => ({
+		kind: "duplicate_email_in_booking_context",
+		email,
+		slotKeys
+	}));
+}
+function isEmailLike(value) {
+	const atIndex = value.indexOf("@");
+	return atIndex > 0 && atIndex === value.lastIndexOf("@") && atIndex < value.length - 1;
+}
+function assertNever$1(value) {
+	throw new Error(`Unexpected participant variant: ${JSON.stringify(value)}`);
+}
+
+//#endregion
+//#region ../core/src/participant-identity.ts
+function planPersonResolution(input) {
+	switch (input.kind) {
+		case "with_email":
+			if (input.existingParticipantIdByEmail !== null) {
+				return {
+					kind: "reuse_existing_person_by_email",
+					participantId: input.existingParticipantIdByEmail,
+					email: input.email
+				};
+			}
+			return {
+				kind: "create_contactable_person",
+				seed: {
+					displayName: input.displayName,
+					email: input.email,
+					phone: input.phone
+				}
+			};
+		case "without_email": return {
+			kind: "create_provisional_person",
+			seed: {
+				displayName: input.displayName,
+				phone: input.phone
+			}
+		};
+		default: return assertNever(input);
+	}
+}
+function planCustomerPersonResolution(input) {
+	const resolution = planPersonResolution(toCustomerPersonResolutionInput(input));
+	switch (resolution.kind) {
+		case "reuse_existing_person_by_email": return {
+			kind: "link_existing_person_by_email",
+			customerId: input.customerId,
+			participantId: resolution.participantId,
+			email: resolution.email
+		};
+		case "create_contactable_person": return {
+			kind: "create_contactable_person_for_customer",
+			customerId: input.customerId,
+			seed: resolution.seed
+		};
+		case "create_provisional_person": return {
+			kind: "create_provisional_person_for_customer",
+			customerId: input.customerId,
+			seed: resolution.seed
+		};
+		default: return assertNever(resolution);
+	}
+}
+function toCustomerPersonResolutionInput(input) {
+	switch (input.kind) {
+		case "with_email": return {
+			kind: "with_email",
+			displayName: input.displayName,
+			email: input.email,
+			phone: input.phone,
+			existingParticipantIdByEmail: input.existingParticipantIdByEmail
+		};
+		case "without_email": return {
+			kind: "without_email",
+			displayName: input.displayName,
+			phone: input.phone
+		};
+		default: return assertNever(input);
+	}
+}
+function planParticipationPersonResolution(input) {
+	switch (input.resolution.kind) {
+		case "blocked_duplicate_participant_in_booking": return {
+			kind: "blocked_duplicate_participant_in_booking",
+			slotKey: input.resolution.slotKey,
+			email: input.resolution.email,
+			conflictingSlotKeys: input.resolution.conflictingSlotKeys
+		};
+		case "create_participant":
+		case "reuse_participant_by_site_email":
+		case "staff_managed_slot": return applyParticipationResolutionPlan({
+			slotKey: input.resolution.slotKey,
+			participation: input.slot.participation,
+			resolution: planPersonResolution(toSlotPersonResolutionInput({
+				slot: input.slot,
+				resolution: input.resolution
+			}))
+		});
+		default: return assertNever(input.resolution);
+	}
+}
+function toSlotPersonResolutionInput(input) {
+	switch (input.resolution.kind) {
+		case "create_participant": return {
+			kind: "with_email",
+			displayName: input.resolution.displayName,
+			email: input.resolution.email,
+			phone: input.resolution.phone,
+			existingParticipantIdByEmail: null
+		};
+		case "reuse_participant_by_site_email": return {
+			kind: "with_email",
+			displayName: input.slot.displayName,
+			email: input.resolution.email,
+			phone: input.slot.phone,
+			existingParticipantIdByEmail: input.resolution.participantId
+		};
+		case "staff_managed_slot": return {
+			kind: "without_email",
+			displayName: input.slot.displayName,
+			phone: input.slot.phone
+		};
+		default: return assertNever(input.resolution);
+	}
+}
+function applyParticipationResolutionPlan(input) {
+	switch (input.resolution.kind) {
+		case "reuse_existing_person_by_email": return {
+			kind: "reuse_existing_person_for_slot",
+			slotKey: input.slotKey,
+			participantId: input.resolution.participantId,
+			participation: input.participation
+		};
+		case "create_contactable_person": return {
+			kind: "create_contactable_person_for_slot",
+			slotKey: input.slotKey,
+			seed: input.resolution.seed,
+			participation: input.participation
+		};
+		case "create_provisional_person": return {
+			kind: "create_provisional_person_for_slot",
+			slotKey: input.slotKey,
+			seed: input.resolution.seed,
+			participation: input.participation
+		};
+		default: return assertNever(input.resolution);
+	}
+}
+function planSingleSubjectParticipantMaterialization(input) {
+	const resolution = planPersonResolution(toSingleSubjectPersonResolutionInput(input));
+	switch (resolution.kind) {
+		case "reuse_existing_person_by_email": return {
+			kind: "reuse_existing_person_and_participation",
+			customerId: input.customerId,
+			participantId: resolution.participantId,
+			participation: input.participation
+		};
+		case "create_contactable_person": return {
+			kind: "create_contactable_person_and_participation",
+			customerId: input.customerId,
+			seed: resolution.seed,
+			participation: input.participation
+		};
+		case "create_provisional_person": return {
+			kind: "create_provisional_person_and_participation",
+			customerId: input.customerId,
+			seed: resolution.seed,
+			participation: input.participation
+		};
+		default: return assertNever(resolution);
+	}
+}
+function toSingleSubjectPersonResolutionInput(input) {
+	switch (input.kind) {
+		case "participant_subject": return {
+			kind: "with_email",
+			displayName: input.displayName,
+			email: input.email,
+			phone: input.phone,
+			existingParticipantIdByEmail: input.existingParticipantIdByEmail
+		};
+		case "provisional_single_subject_participant": return {
+			kind: "without_email",
+			displayName: input.displayName,
+			phone: input.phone
+		};
+		default: return assertNever(input);
+	}
+}
+function planCleanupReadiness(evidence) {
+	const blockers = collectCleanupReadinessBlockers(evidence);
+	if (blockers.length === 0) {
+		return {
+			kind: "ready",
+			evidence,
+			blockers: []
+		};
+	}
+	return {
+		kind: "blocked",
+		evidence,
+		blockers
+	};
+}
+function collectCleanupReadinessBlockers(evidence) {
+	const blockers = [];
+	if (evidence.legacyCustomerEmailCallSiteCount > 0) {
+		blockers.push("legacy_customer_email_call_sites_remaining");
+	}
+	if (evidence.parityFailureSurfaces.length > 0) {
+		blockers.push("parity_failures_remaining");
+	}
+	if (evidence.unresolvedHealthRowCount > 0) {
+		blockers.push("unresolved_health_rows_remaining");
+	}
+	return blockers;
+}
+
+//#endregion
+//#region ../core/src/public-url-validation.ts
+function buildPublicUrlValidationError(message, errorFactory) {
+	return errorFactory !== undefined ? errorFactory(message) : new Error(message);
+}
+function parseIpv4(ip) {
+	const parts = ip.split(".");
+	if (parts.length !== 4) return null;
+	const bytes = parts.map((p) => {
+		if (!/^\d+$/.test(p)) return Number.NaN;
+		const n = Number.parseInt(p, 10);
+		return n >= 0 && n <= 255 ? n : Number.NaN;
+	});
+	if (bytes.some((b) => !Number.isFinite(b))) return null;
+	return bytes;
+}
+function parseIpv6(ip) {
+	const normalized = ip.toLowerCase();
+	const zoneIndex = normalized.indexOf("%");
+	const withoutZone = zoneIndex >= 0 ? normalized.slice(0, zoneIndex) : normalized;
+	const expandSection = (section) => {
+		if (!section) return [];
+		const parts = section.split(":");
+		const expanded$1 = [];
+		for (const part of parts) {
+			if (!part) return null;
+			if (part.includes(".")) {
+				const ipv4 = parseIpv4(part);
+				if (ipv4 === null) return null;
+				const [a, b, c, d] = ipv4;
+				if (a === undefined || b === undefined || c === undefined || d === undefined) {
+					return null;
+				}
+				expanded$1.push(a << 8 | b, c << 8 | d);
+				continue;
+			}
+			if (!/^[0-9a-f]{1,4}$/i.test(part)) return null;
+			expanded$1.push(Number.parseInt(part, 16));
+		}
+		return expanded$1;
+	};
+	const doubleColonIndex = withoutZone.indexOf("::");
+	if (doubleColonIndex !== withoutZone.lastIndexOf("::")) return null;
+	if (doubleColonIndex >= 0) {
+		const head = withoutZone.slice(0, doubleColonIndex);
+		const tail = withoutZone.slice(doubleColonIndex + 2);
+		const headParts = expandSection(head);
+		const tailParts = expandSection(tail);
+		if (headParts === null || tailParts === null) return null;
+		const zerosToInsert = 8 - (headParts.length + tailParts.length);
+		if (zerosToInsert < 1) return null;
+		return [
+			...headParts,
+			...Array.from({ length: zerosToInsert }, () => 0),
+			...tailParts
+		];
+	}
+	const expanded = expandSection(withoutZone);
+	if (expanded === null || expanded.length !== 8) return null;
+	return expanded;
+}
+function isPrivateIpv4(ip) {
+	const bytes = parseIpv4(ip);
+	if (bytes === null) return true;
+	const a = bytes[0];
+	const b = bytes[1];
+	if (a === undefined || b === undefined) return true;
+	if (a === 0) return true;
+	if (a === 10) return true;
+	if (a === 127) return true;
+	if (a === 169 && b === 254) return true;
+	if (a === 172) {
+		if (b >= 16 && b <= 31) return true;
+	}
+	if (a === 192 && b === 0 && bytes[2] === 0) return true;
+	if (a === 192 && b === 0 && bytes[2] === 2) return true;
+	if (a === 192 && b === 168) return true;
+	if (a === 100) {
+		if (b >= 64 && b <= 127) return true;
+	}
+	if (a === 198 && (b === 18 || b === 19)) return true;
+	if (a === 198 && b === 51 && bytes[2] === 100) return true;
+	if (a === 203 && b === 0 && bytes[2] === 113) return true;
+	if (a >= 224) return true;
+	return false;
+}
+function isPrivateIpv6(ip) {
+	const normalized = ip.toLowerCase();
+	if (normalized === "::" || normalized === "::1") return true;
+	if (normalized.startsWith("::ffff:")) {
+		const maybeV4 = normalized.slice("::ffff:".length);
+		if (parseIpv4(maybeV4) !== null) return isPrivateIpv4(maybeV4);
+		return true;
+	}
+	const hextets = parseIpv6(normalized);
+	if (hextets === null) return true;
+	const first = hextets[0] ?? 0;
+	const second = hextets[1] ?? 0;
+	const third = hextets[2] ?? 0;
+	const fourth = hextets[3] ?? 0;
+	if ((first & 65024) === 64512) return true;
+	if ((first & 65472) === 65152) return true;
+	if (first === 256 && second === 0 && third === 0 && fourth === 0) return true;
+	if (first === 8193 && second === 3512) return true;
+	if (first === 8193 && (second & 65520) === 16) return true;
+	if (first === 8194) return true;
+	return false;
+}
+function isIpAddress(value) {
+	return parseIpv4(value) !== null || parseIpv6(value) !== null;
+}
+function isPrivateIp(ip) {
+	if (parseIpv4(ip) !== null) return isPrivateIpv4(ip);
+	if (parseIpv6(ip) !== null) return isPrivateIpv6(ip);
+	return true;
+}
+function assertAllowedPublicHostname(hostname, errorFactory) {
+	const host = hostname.trim().toLowerCase().replace(/[。\uFF0E\uFF61]/gu, ".").replace(/\.+$/u, "");
+	if (host.length === 0) throw buildPublicUrlValidationError("URL host is missing", errorFactory);
+	if (host === "localhost" || host.endsWith(".localhost")) {
+		throw buildPublicUrlValidationError("Localhost hosts are not allowed", errorFactory);
+	}
+	if (/^[0-9.]+$/.test(host) && !isIpAddress(host)) {
+		throw buildPublicUrlValidationError("Numeric hosts are not allowed", errorFactory);
+	}
+}
+function assertAllowedPort(url, options) {
+	const { portPolicy, errorFactory } = options;
+	const port = url.port.length > 0 ? Number.parseInt(url.port, 10) : null;
+	if (port !== null && (!Number.isFinite(port) || port <= 0 || port > 65535)) {
+		throw buildPublicUrlValidationError("Invalid port", errorFactory);
+	}
+	if (portPolicy === "standard-only") {
+		const allowedPort = url.protocol === "http:" ? 80 : 443;
+		if (port !== null && port !== allowedPort) {
+			throw buildPublicUrlValidationError("Non-standard ports are not allowed", errorFactory);
+		}
+	}
+}
+function assertAllowedPublicUrl(raw, options) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw buildPublicUrlValidationError("Invalid URL", options.errorFactory);
+	}
+	if (!options.allowedProtocols.includes(url.protocol)) {
+		throw buildPublicUrlValidationError(`Only ${options.allowedProtocols.join("/")} URLs are allowed`, options.errorFactory);
+	}
+	if (url.username || url.password) {
+		throw buildPublicUrlValidationError("Credentialed URLs are not allowed", options.errorFactory);
+	}
+	const normalizedHostname = url.hostname.trim().toLowerCase().replace(/[。\uFF0E\uFF61]/gu, ".").replace(/\.+$/u, "");
+	if (normalizedHostname.length === 0) {
+		throw buildPublicUrlValidationError("URL host is missing", options.errorFactory);
+	}
+	url.hostname = normalizedHostname;
+	assertAllowedPublicHostname(url.hostname, options.errorFactory);
+	assertAllowedPort(url, options);
+	const hostnameForIpCheck = url.hostname.startsWith("[") && url.hostname.endsWith("]") ? url.hostname.slice(1, -1) : url.hostname;
+	if (isIpAddress(hostnameForIpCheck) && isPrivateIp(hostnameForIpCheck)) {
+		throw buildPublicUrlValidationError("Private IPs are not allowed", options.errorFactory);
+	}
+	url.hash = "";
+	return url;
+}
+
+//#endregion
+//#region ../core/src/public-profile.ts
+const publicProfileWeekdays = [
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday",
+	"sunday"
+];
+const knownSocialPlatforms = [
+	"facebook",
+	"instagram",
+	"linkedin",
+	"tiktok",
+	"x",
+	"youtube"
+];
+function isRecord$5(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function trimmedOptionalString(value) {
+	if (value === null || value === undefined) return null;
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function parsePublicContactDetails(value) {
+	if (!isRecord$5(value)) {
+		return err({
+			code: "invalid_shape",
+			path: "contact",
+			message: "Contact details must be an object."
+		});
+	}
+	const phone = trimmedOptionalString(value.phone);
+	const email = trimmedOptionalString(value.email);
+	if (phone === undefined || email === undefined) {
+		return err({
+			code: "invalid_shape",
+			path: "contact",
+			message: "Phone and email must be text values."
+		});
+	}
+	if (phone === null && email === null) {
+		return err({
+			code: "contact_method_required",
+			path: "contact",
+			message: "Add a phone number or email address."
+		});
+	}
+	if (email !== null && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/u.test(email)) {
+		return err({
+			code: "invalid_email",
+			path: "contact.email",
+			message: "Enter a valid email address."
+		});
+	}
+	if (phone !== null && !/^\+?[0-9][0-9 ().-]{5,30}$/u.test(phone)) {
+		return err({
+			code: "invalid_phone",
+			path: "contact.phone",
+			message: "Enter a valid phone number."
+		});
+	}
+	if (phone !== null && email !== null) {
+		return ok({
+			kind: "phone-and-email",
+			phone,
+			email
+		});
+	}
+	if (phone !== null) return ok({
+		kind: "phone",
+		phone,
+		email: null
+	});
+	if (email !== null) return ok({
+		kind: "email",
+		phone: null,
+		email
+	});
+	return err({
+		code: "contact_method_required",
+		path: "contact",
+		message: "Add a phone number or email address."
+	});
+}
+function parsePublicProfileTimeZone(value) {
+	const timeZone = trimmedOptionalString(value);
+	if (timeZone === null || timeZone === undefined) {
+		return err({
+			code: "invalid_timezone",
+			path: "openingHours.timeZone",
+			message: "Choose a timezone."
+		});
+	}
+	try {
+		new Intl.DateTimeFormat("en-GB", { timeZone }).format(new Date(0));
+		return ok(timeZone);
+	} catch {
+		return err({
+			code: "invalid_timezone",
+			path: "openingHours.timeZone",
+			message: "Choose a valid IANA timezone."
+		});
+	}
+}
+function parseOpeningHoursTime(value, path) {
+	if (typeof value !== "string" || !/^(?:[01]\d|2[0-3]):[0-5]\d$/u.test(value)) {
+		return err({
+			code: "invalid_time",
+			path,
+			message: "Use a 24-hour time such as 09:00."
+		});
+	}
+	return ok(value);
+}
+function minutesSinceMidnight(value) {
+	const [hours = "0", minutes = "0"] = value.split(":");
+	return Number(hours) * 60 + Number(minutes);
+}
+function parseOpeningHoursDay(value, expectedWeekday, index) {
+	const path = `openingHours.days.${index}`;
+	if (!isRecord$5(value) || value.weekday !== expectedWeekday) {
+		return err({
+			code: "invalid_weekdays",
+			path,
+			message: `Expected ${expectedWeekday} in calendar order.`
+		});
+	}
+	if (value.kind === "closed") return ok({
+		kind: "closed",
+		weekday: expectedWeekday
+	});
+	if (value.kind !== "open" || !Array.isArray(value.intervals) || value.intervals.length === 0) {
+		return err({
+			code: "invalid_interval",
+			path: `${path}.intervals`,
+			message: "Open days need at least one opening interval."
+		});
+	}
+	const intervals = [];
+	for (const [intervalIndex, rawInterval] of value.intervals.entries()) {
+		const intervalPath = `${path}.intervals.${intervalIndex}`;
+		if (!isRecord$5(rawInterval)) {
+			return err({
+				code: "invalid_interval",
+				path: intervalPath,
+				message: "Opening interval is invalid."
+			});
+		}
+		const opensAt = parseOpeningHoursTime(rawInterval.opensAt, `${intervalPath}.opensAt`);
+		if (!opensAt.ok) return opensAt;
+		const closesAt = parseOpeningHoursTime(rawInterval.closesAt, `${intervalPath}.closesAt`);
+		if (!closesAt.ok) return closesAt;
+		if (minutesSinceMidnight(opensAt.value) >= minutesSinceMidnight(closesAt.value)) {
+			return err({
+				code: "invalid_interval",
+				path: intervalPath,
+				message: "Closing time must be later than opening time on the same day."
+			});
+		}
+		intervals.push({
+			opensAt: opensAt.value,
+			closesAt: closesAt.value
+		});
+	}
+	intervals.sort((left, right) => minutesSinceMidnight(left.opensAt) - minutesSinceMidnight(right.opensAt));
+	for (let intervalIndex = 1; intervalIndex < intervals.length; intervalIndex += 1) {
+		const previous = intervals[intervalIndex - 1];
+		const current = intervals[intervalIndex];
+		if (previous !== undefined && current !== undefined && minutesSinceMidnight(current.opensAt) < minutesSinceMidnight(previous.closesAt)) {
+			return err({
+				code: "overlapping_intervals",
+				path: `${path}.intervals.${intervalIndex}`,
+				message: "Opening intervals cannot overlap."
+			});
+		}
+	}
+	const [first, ...rest] = intervals;
+	if (first === undefined) {
+		return err({
+			code: "invalid_interval",
+			path,
+			message: "Open days need an opening interval."
+		});
+	}
+	return ok({
+		kind: "open",
+		weekday: expectedWeekday,
+		intervals: [first, ...rest]
+	});
+}
+function parseWeeklyOpeningHours(value) {
+	if (!isRecord$5(value) || !Array.isArray(value.days) || value.days.length !== publicProfileWeekdays.length) {
+		return err({
+			code: "invalid_weekdays",
+			path: "openingHours.days",
+			message: "Opening hours must include all seven weekdays."
+		});
+	}
+	const timeZone = parsePublicProfileTimeZone(value.timeZone);
+	if (!timeZone.ok) return timeZone;
+	const days = [];
+	for (const [index, weekday] of publicProfileWeekdays.entries()) {
+		const day = parseOpeningHoursDay(value.days[index], weekday, index);
+		if (!day.ok) return day;
+		days.push(day.value);
+	}
+	const [monday, tuesday, wednesday, thursday, friday, saturday, sunday] = days;
+	if (monday === undefined || tuesday === undefined || wednesday === undefined || thursday === undefined || friday === undefined || saturday === undefined || sunday === undefined) {
+		return err({
+			code: "invalid_weekdays",
+			path: "openingHours.days",
+			message: "Opening hours are incomplete."
+		});
+	}
+	return ok({
+		timeZone: timeZone.value,
+		days: [
+			monday,
+			tuesday,
+			wednesday,
+			thursday,
+			friday,
+			saturday,
+			sunday
+		]
+	});
+}
+function parseSocialLinkId(value, path) {
+	if (typeof value !== "string" || !/^[a-z0-9][a-z0-9_-]{0,63}$/u.test(value)) {
+		return err({
+			code: "invalid_social_link",
+			path,
+			message: "Social link ID is invalid."
+		});
+	}
+	return ok(value);
+}
+function parseSocialUrl(value, path) {
+	if (typeof value !== "string") {
+		return err({
+			code: "invalid_social_link",
+			path,
+			message: "Enter a valid public web address."
+		});
+	}
+	try {
+		const url = assertAllowedPublicUrl(value.trim(), {
+			allowedProtocols: ["https:", "http:"],
+			portPolicy: "standard-only"
+		});
+		return ok(url.toString());
+	} catch {
+		return err({
+			code: "invalid_social_link",
+			path,
+			message: "Enter a valid public web address."
+		});
+	}
+}
+function parsePublicSocialLinks(value) {
+	if (!Array.isArray(value)) {
+		return err({
+			code: "invalid_shape",
+			path: "socialLinks",
+			message: "Social links must be a list."
+		});
+	}
+	const links = [];
+	const ids = new Set();
+	for (const [index, rawLink] of value.entries()) {
+		const path = `socialLinks.${index}`;
+		if (!isRecord$5(rawLink)) {
+			return err({
+				code: "invalid_social_link",
+				path,
+				message: "Social link is invalid."
+			});
+		}
+		const id = parseSocialLinkId(rawLink.id, `${path}.id`);
+		if (!id.ok) return id;
+		if (ids.has(id.value)) {
+			return err({
+				code: "duplicate_social_link_id",
+				path: `${path}.id`,
+				message: "Social link IDs must be unique."
+			});
+		}
+		ids.add(id.value);
+		const url = parseSocialUrl(rawLink.url, `${path}.url`);
+		if (!url.ok) return url;
+		if (rawLink.kind === "known" && knownSocialPlatforms.includes(rawLink.platform)) {
+			links.push({
+				id: id.value,
+				kind: "known",
+				platform: rawLink.platform,
+				url: url.value
+			});
+			continue;
+		}
+		const label = trimmedOptionalString(rawLink.label);
+		if (rawLink.kind === "custom" && label !== null && label !== undefined) {
+			links.push({
+				id: id.value,
+				kind: "custom",
+				label,
+				url: url.value
+			});
+			continue;
+		}
+		return err({
+			code: "invalid_social_link",
+			path,
+			message: "Choose a known platform or add a custom label."
+		});
+	}
+	return ok(links);
+}
+function parsePublicProfile(value) {
+	if (!isRecord$5(value)) {
+		return err({
+			code: "invalid_shape",
+			path: "",
+			message: "Public profile must be an object."
+		});
+	}
+	const contact = value.contact === null ? ok(null) : parsePublicContactDetails(value.contact);
+	if (!contact.ok) return contact;
+	const openingHours = value.openingHours === null ? ok(null) : parseWeeklyOpeningHours(value.openingHours);
+	if (!openingHours.ok) return openingHours;
+	const socialLinks = parsePublicSocialLinks(value.socialLinks);
+	if (!socialLinks.ok) return socialLinks;
+	return ok({
+		contact: contact.value,
+		openingHours: openingHours.value,
+		socialLinks: socialLinks.value
+	});
+}
+function emptyPublicProfile() {
+	return {
+		contact: null,
+		openingHours: null,
+		socialLinks: []
+	};
+}
+
+//#endregion
+//#region ../core/src/rich-text.ts
+function isRecord$4(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+	return Object.keys(value).every((key) => allowed.has(key));
+}
+const rootKeys = new Set(["type", "content"]);
+const nodeKeys = new Set([
+	"type",
+	"content",
+	"text",
+	"attrs",
+	"marks"
+]);
+const markKeys = new Set(["type", "attrs"]);
+function isDenseArrayOf(value, predicate) {
+	for (let index = 0; index < value.length; index += 1) {
+		if (!(index in value) || !predicate(value[index])) return false;
+	}
+	return true;
+}
+function isTipTapMark(value) {
+	return isRecord$4(value) && hasOnlyKeys(value, markKeys) && typeof value.type === "string" && value.type.length > 0 && (value.attrs === undefined || isRecord$4(value.attrs));
+}
+function isTipTapNode(value) {
+	if (!isRecord$4(value) || !hasOnlyKeys(value, nodeKeys) || typeof value.type !== "string" || value.type.length === 0 || value.type === "doc" || value.attrs !== undefined && !isRecord$4(value.attrs) || value.marks !== undefined && (!Array.isArray(value.marks) || !isDenseArrayOf(value.marks, isTipTapMark)) || value.content !== undefined && (!Array.isArray(value.content) || !isDenseArrayOf(value.content, isTipTapNode))) {
+		return false;
+	}
+	if (value.type === "text") {
+		return typeof value.text === "string" && value.text.length > 0 && value.content === undefined;
+	}
+	return value.text === undefined;
+}
+function isCanonicalRichTextDoc(value) {
+	return isRecord$4(value) && hasOnlyKeys(value, rootKeys) && value.type === "doc" && Array.isArray(value.content) && isDenseArrayOf(value.content, isTipTapNode);
+}
+
+//#endregion
+//#region ../core/src/newsletter-signup-destination.ts
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const MAILCHIMP_AUDIENCE_ID_PATTERN = /^[A-Za-z0-9_-]{1,100}$/u;
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/u;
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseTrimmedString(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function parseNewsletterListId(value) {
+	const trimmed = parseTrimmedString(value);
+	return trimmed !== null && UUID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseMailchimpConnectionId(value) {
+	const trimmed = parseTrimmedString(value);
+	return trimmed !== null && UUID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseMailchimpAudienceId(value) {
+	const trimmed = parseTrimmedString(value);
+	return trimmed !== null && MAILCHIMP_AUDIENCE_ID_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseMailchimpTagName(value) {
+	const trimmed = parseTrimmedString(value);
+	return trimmed !== null && trimmed.length <= 100 && !CONTROL_CHARACTER_PATTERN.test(trimmed) ? trimmed : null;
+}
+function parseNewsletterSignupDestinationProvider(value) {
+	return value === "riverbank" || value === "mailchimp" ? value : null;
+}
+function parseNewsletterSignupAuthoringDestinationValue(value) {
+	if (!isRecord$3(value) || typeof value.tag !== "string") {
+		return err({ kind: "invalid-destination-shape" });
+	}
+	switch (value.tag) {
+		case "riverbank_list": {
+			const listId = parseNewsletterListId(value.listId);
+			return listId === null ? err({ kind: "invalid-newsletter-list-id" }) : ok({
+				tag: "riverbank_list",
+				listId
+			});
+		}
+		case "mailchimp_audience": {
+			const connectionId = parseMailchimpConnectionId(value.connectionId);
+			if (connectionId === null) {
+				return err({ kind: "invalid-mailchimp-connection-id" });
+			}
+			const audienceId = parseMailchimpAudienceId(value.audienceId);
+			if (audienceId === null) {
+				return err({ kind: "invalid-mailchimp-audience-id" });
+			}
+			const rawTags = value.tags ?? [];
+			if (!Array.isArray(rawTags)) {
+				return err({ kind: "invalid-mailchimp-tags" });
+			}
+			const tags = [];
+			for (const valueTag of rawTags) {
+				const tag = parseMailchimpTagName(valueTag);
+				if (tag === null) return err({ kind: "invalid-mailchimp-tags" });
+				tags.push(tag);
+			}
+			return ok({
+				tag: "mailchimp_audience",
+				connectionId,
+				audienceId,
+				tags
+			});
+		}
+		default: return err({
+			kind: "invalid-destination-tag",
+			value: value.tag
+		});
+	}
+}
+
+//#endregion
+//#region ../core/src/footer-engagement.ts
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalid(path, message) {
+	return {
+		code: "invalid_section",
+		path,
+		message
+	};
+}
+function parseBoundedText(value, path, options) {
+	if (options.optional === true && (value === null || value === undefined)) {
+		return ok(null);
+	}
+	if (typeof value !== "string") {
+		return err(invalid(path, "Footer engagement copy must be text."));
+	}
+	const text = value.trim();
+	if (text.length === 0) {
+		return options.optional === true ? ok(null) : err(invalid(path, "Footer engagement copy cannot be empty."));
+	}
+	return text.length <= options.maxLength ? ok(text) : err(invalid(path, `Footer engagement copy must be ${options.maxLength} characters or fewer.`));
+}
+function parseTreatment(value, path) {
+	return value === "integrated" || value === "separate-row" ? ok(value) : err(invalid(path, "Footer engagement treatment is invalid."));
+}
+function parseEngagementBase(value, base, path) {
+	const heading = parseBoundedText(value.heading, `${path}.heading`, { maxLength: 80 });
+	if (!heading.ok) return heading;
+	if (heading.value === null) {
+		return err(invalid(`${path}.heading`, "Footer engagement heading cannot be empty."));
+	}
+	const treatment = parseTreatment(value.treatment, `${path}.treatment`);
+	if (!treatment.ok) return treatment;
+	if (!isRecord$2(value.source)) {
+		return err(invalid(`${path}.source`, "Footer engagement source is invalid."));
+	}
+	const intro = parseBoundedText(value.source.intro, `${path}.source.intro`, {
+		maxLength: 240,
+		optional: true
+	});
+	return intro.ok ? ok({
+		...base,
+		heading: heading.value,
+		treatment: treatment.value,
+		intro: intro.value
+	}) : intro;
+}
+function parseStandardContact(source, base, path) {
+	const formId = parseFormId(source.formId);
+	const { intro, ...section } = base;
+	return formId.ok ? ok({
+		...section,
+		kind: "engagement",
+		source: {
+			kind: "standard-contact",
+			formId: formId.value,
+			intro
+		}
+	}) : err(invalid(`${path}.formId`, "Footer engagement form ID is invalid."));
+}
+function parseMailingList(source, base, path) {
+	const { intro, ...section } = base;
+	const destination = parseNewsletterSignupAuthoringDestinationValue(source.destination);
+	if (!destination.ok) {
+		return err(invalid(`${path}.destination`, "Footer mailing-list destination is invalid."));
+	}
+	const buttonLabel = parseBoundedText(source.buttonLabel, `${path}.buttonLabel`, { maxLength: 40 });
+	if (!buttonLabel.ok) return buttonLabel;
+	const successMessage = parseBoundedText(source.successMessage, `${path}.successMessage`, { maxLength: 160 });
+	if (!successMessage.ok) return successMessage;
+	const privacyNote = parseBoundedText(source.privacyNote, `${path}.privacyNote`, {
+		maxLength: 240,
+		optional: true
+	});
+	if (!privacyNote.ok) return privacyNote;
+	if (buttonLabel.value === null || successMessage.value === null) {
+		return err(invalid(path, "Footer mailing-list copy cannot be empty."));
+	}
+	if (source.fieldPreset !== "emailOnly") {
+		return err(invalid(`${path}.fieldPreset`, "Footer mailing-list signup must be email-only."));
+	}
+	return ok({
+		...section,
+		kind: "engagement",
+		source: {
+			kind: "mailing-list",
+			destination: destination.value,
+			intro,
+			buttonLabel: buttonLabel.value,
+			successMessage: successMessage.value,
+			privacyNote: privacyNote.value,
+			fieldPreset: "emailOnly"
+		}
+	});
+}
+function parseFooterEngagementSectionValue(value, sectionBase, path) {
+	const base = parseEngagementBase(value, sectionBase, path);
+	if (!base.ok) return base;
+	const source = value.source;
+	if (!isRecord$2(source)) {
+		return err(invalid(`${path}.source`, "Footer engagement source is invalid."));
+	}
+	switch (source.kind) {
+		case "standard-contact": return parseStandardContact(source, base.value, `${path}.source`);
+		case "mailing-list": return parseMailingList(source, base.value, `${path}.source`);
+		default: return err(invalid(`${path}.source.kind`, "Footer engagement source kind is invalid."));
+	}
+}
+
+//#endregion
+//#region ../core/src/footer-arrangement.ts
+const sectionKinds = [
+	"brand",
+	"supporting-text",
+	"social-links",
+	"navigation",
+	"business-address",
+	"contact",
+	"opening-hours",
+	"engagement",
+	"legal-navigation",
+	"legal"
+];
+const sectionKindOrder = new Map(sectionKinds.map((kind, index) => [kind, index]));
+const visualGroupOrder = [
+	"identity",
+	"main-navigation",
+	"visit",
+	"engagement",
+	"legal-ending"
+];
+function groupFor(kind) {
+	switch (kind) {
+		case "brand":
+		case "supporting-text":
+		case "social-links": return "identity";
+		case "navigation": return "main-navigation";
+		case "business-address":
+		case "contact":
+		case "opening-hours": return "visit";
+		case "engagement": return "engagement";
+		case "legal-navigation":
+		case "legal": return "legal-ending";
+	}
+}
+function buildGroups(sections, navigationLayout) {
+	const groups = new Map();
+	for (const section of sections) {
+		const kind = groupFor(section.kind);
+		groups.set(kind, [...groups.get(kind) ?? [], section]);
+	}
+	return visualGroupOrder.flatMap((kind) => {
+		const groupSections = groups.get(kind);
+		return groupSections === undefined || groupSections.length === 0 ? [] : [{
+			kind,
+			width: kind === "main-navigation" && navigationLayout === "inline-wrap" ? "full-row" : "column",
+			sections: [...groupSections].sort((left, right) => (sectionKindOrder.get(left.kind) ?? Number.MAX_SAFE_INTEGER) - (sectionKindOrder.get(right.kind) ?? Number.MAX_SAFE_INTEGER))
+		}];
+	});
+}
+function membershipKey(sections) {
+	const tokens = sections.map((section) => ({
+		rank: sectionKindOrder.get(section.kind) ?? Number.MAX_SAFE_INTEGER,
+		value: section.kind === "engagement" ? `engagement:${section.treatment}` : section.kind
+	}));
+	tokens.sort((left, right) => left.rank - right.rank);
+	return tokens.map(({ value }) => value).join("+") || "empty";
+}
+function planFooterArrangement(renderableSections, policy) {
+	const selectedSections = renderableSections.map(({ section }) => section);
+	const groups = buildGroups(selectedSections, policy.navigationLayout);
+	const engagement = selectedSections.find((section) => section.kind === "engagement");
+	const separateEngagement = engagement?.treatment === "separate-row" ? groups.filter((group) => group.kind === "engagement") : [];
+	const layoutGroups = separateEngagement.length === 0 ? groups : groups.filter((group) => group.kind !== "engagement");
+	const legalGroups = layoutGroups.filter((group) => group.kind === "legal-ending");
+	const unsortedMainGroups = policy.kind === "separate-legal-region" ? layoutGroups.filter((group) => group.kind !== "legal-ending") : layoutGroups;
+	const mainGroups = [...unsortedMainGroups.filter((group) => group.width === "column"), ...unsortedMainGroups.filter((group) => group.width === "full-row")];
+	const regions = [];
+	if (separateEngagement.length > 0) {
+		regions.push({
+			kind: "engagement-row",
+			columns: 1,
+			groups: separateEngagement
+		});
+	}
+	if (mainGroups.length > 0) {
+		regions.push({
+			kind: "main",
+			columns: Math.max(1, Math.min(mainGroups.filter((group) => group.width === "column").length, 5)),
+			groups: mainGroups
+		});
+	}
+	if (policy.kind === "separate-legal-region" && legalGroups.length > 0) {
+		regions.push({
+			kind: "bottom",
+			columns: 1,
+			groups: legalGroups
+		});
+	}
+	return {
+		membershipKey: membershipKey(selectedSections),
+		regions,
+		mobileGroups: separateEngagement.length === 0 ? groups : [...separateEngagement, ...layoutGroups]
+	};
+}
+
+//#endregion
+//#region ../core/src/footer-composition.ts
+function unsafeAsFooterModuleId(value) {
+	return value;
+}
+function parseFooterModuleId(value) {
+	return parseSectionId(value, "sectionId");
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRichText(value) {
+	return isCanonicalRichTextDoc(value);
+}
+function parseSectionId(value, path) {
+	if (typeof value !== "string" || !/^[a-z0-9][a-z0-9_-]{0,63}$/u.test(value)) {
+		return err({
+			code: "invalid_section",
+			path,
+			message: "Footer section ID is invalid."
+		});
+	}
+	return ok(unsafeAsFooterModuleId(value));
+}
+function parseHeading(value, path) {
+	if (value === null || value === undefined) return ok(null);
+	if (typeof value !== "string") {
+		return err({
+			code: "invalid_section",
+			path,
+			message: "Footer heading must be text."
+		});
+	}
+	const heading = value.trim();
+	return ok(heading.length > 0 ? heading : null);
+}
+function parseFooterSection(value, index) {
+	const path = `sections.${index}`;
+	if (!isRecord$1(value)) {
+		return err({
+			code: "invalid_section",
+			path,
+			message: "Footer section must be an object."
+		});
+	}
+	const id = parseSectionId(value.id, `${path}.id`);
+	if (!id.ok) return id;
+	const heading = parseHeading(value.heading, `${path}.heading`);
+	if (!heading.ok) return heading;
+	if (typeof value.selected !== "boolean") {
+		return err({
+			code: "invalid_section",
+			path: `${path}.selected`,
+			message: "Footer selection intent is missing."
+		});
+	}
+	const base = {
+		id: id.value,
+		selected: value.selected
+	};
+	switch (value.kind) {
+		case "brand":
+			if (typeof value.showLogo === "boolean" && typeof value.showTitle === "boolean") {
+				return ok({
+					...base,
+					kind: "brand",
+					heading: heading.value,
+					showLogo: value.showLogo,
+					showTitle: value.showTitle
+				});
+			}
+			break;
+		case "navigation":
+			if (isRecord$1(value.source) && value.source.kind === "menu-role" && value.source.role === "main") {
+				return ok({
+					...base,
+					kind: "navigation",
+					heading: heading.value,
+					source: {
+						kind: "menu-role",
+						role: "main"
+					}
+				});
+			}
+			break;
+		case "legal-navigation":
+			if (isRecord$1(value.source) && value.source.kind === "menu-role" && value.source.role === "legal-policy") {
+				return ok({
+					...base,
+					kind: "legal-navigation",
+					heading: heading.value,
+					source: {
+						kind: "menu-role",
+						role: "legal-policy"
+					}
+				});
+			}
+			break;
+		case "business-address":
+			if (isRecord$1(value.source) && value.source.kind === "business-address") {
+				return ok({
+					...base,
+					kind: "business-address",
+					heading: heading.value,
+					source: { kind: "business-address" }
+				});
+			}
+			break;
+		case "contact":
+		case "opening-hours":
+		case "social-links":
+			if (isRecord$1(value.source) && value.source.kind === "public-profile") {
+				return ok({
+					...base,
+					kind: value.kind,
+					heading: heading.value,
+					source: { kind: "public-profile" }
+				});
+			}
+			break;
+		case "supporting-text":
+		case "legal":
+			if (value.content === null || isRichText(value.content)) {
+				return ok({
+					...base,
+					kind: value.kind,
+					heading: heading.value,
+					content: value.content
+				});
+			}
+			break;
+		case "engagement": return parseFooterEngagementSectionValue(value, base, path);
+	}
+	return err({
+		code: "invalid_section",
+		path,
+		message: "Footer section does not match its declared kind."
+	});
+}
+function validateFooterComposition(composition) {
+	const sectionIds = new Set();
+	const kinds = new Set();
+	for (const [index, section] of composition.sections.entries()) {
+		if (sectionIds.has(section.id)) {
+			return err({
+				code: "duplicate_section_id",
+				path: `sections.${index}.id`,
+				message: "Footer section IDs must be unique."
+			});
+		}
+		sectionIds.add(section.id);
+		if (kinds.has(section.kind)) {
+			return err({
+				code: "duplicate_section_kind",
+				path: `sections.${index}.kind`,
+				message: "Each footer section kind can appear only once."
+			});
+		}
+		kinds.add(section.kind);
+	}
+	return ok(composition);
+}
+function parseFooterCompositionV1(value) {
+	if (!isRecord$1(value)) {
+		return err({
+			code: "invalid_shape",
+			path: "",
+			message: "Footer composition must be an object."
+		});
+	}
+	if (value.schemaVersion !== 1) {
+		return err({
+			code: "unsupported_schema_version",
+			path: "schemaVersion",
+			message: "Footer composition version is not supported."
+		});
+	}
+	if (!Array.isArray(value.sections)) {
+		return err({
+			code: "invalid_shape",
+			path: "sections",
+			message: "Footer sections are missing."
+		});
+	}
+	const sections = [];
+	for (const [index, rawSection] of value.sections.entries()) {
+		const section = parseFooterSection(rawSection, index);
+		if (!section.ok) return section;
+		sections.push(section.value);
+	}
+	return validateFooterComposition({
+		schemaVersion: 1,
+		sections
+	});
+}
+function parseLegacyPlacementSection(value, index, selectedIds) {
+	if (!isRecord$1(value)) {
+		return err({
+			code: "invalid_section",
+			path: `modules.${index}`,
+			message: "Footer module must be an object."
+		});
+	}
+	const selected = typeof value.id === "string" && selectedIds.has(value.id);
+	const source = isRecord$1(value.source) ? value.source : null;
+	const mapped = value.kind === "navigation" && source?.kind === "menu-role" && source.role === "footer" ? {
+		...value,
+		source: {
+			kind: "menu-role",
+			role: "main"
+		},
+		selected
+	} : {
+		...value,
+		selected
+	};
+	return parseFooterSection(mapped, index);
+}
+/**
+* Bounded pre-production upgrader for the placement-shaped V1 that never reached production.
+* It is intentionally not called by the runtime parser.
+*/
+function upgradePlacementFooterCompositionV1(value) {
+	if (!isRecord$1(value) || value.schemaVersion !== 1 || !Array.isArray(value.modules) || !Array.isArray(value.placements)) {
+		return err({
+			code: "invalid_shape",
+			path: "",
+			message: "Placement-based footer composition is invalid."
+		});
+	}
+	const selectedIds = new Set();
+	for (const [index, placement] of value.placements.entries()) {
+		if (!isRecord$1(placement) || typeof placement.moduleId !== "string") {
+			return err({
+				code: "invalid_shape",
+				path: `placements.${index}`,
+				message: "Footer placement is invalid."
+			});
+		}
+		if (selectedIds.has(placement.moduleId)) {
+			return err({
+				code: "invalid_shape",
+				path: `placements.${index}.moduleId`,
+				message: "A legacy footer module can only be placed once."
+			});
+		}
+		selectedIds.add(placement.moduleId);
+	}
+	const sections = [];
+	for (const [index, rawModule] of value.modules.entries()) {
+		const section = parseLegacyPlacementSection(rawModule, index, selectedIds);
+		if (!section.ok) return section;
+		sections.push(section.value);
+	}
+	const sectionIds = new Set(sections.map((section) => section.id));
+	const unknownPlacedId = [...selectedIds].find((sectionId) => !sectionIds.has(sectionId));
+	if (unknownPlacedId !== undefined) {
+		return err({
+			code: "unknown_section",
+			path: "placements",
+			message: `Legacy placement references unknown section ${unknownPlacedId}.`
+		});
+	}
+	return validateFooterComposition({
+		schemaVersion: 1,
+		sections
+	});
+}
+function setFooterSectionSelected(composition, sectionId, selected) {
+	if (!composition.sections.some((section) => section.id === sectionId)) {
+		return err({
+			code: "unknown_section",
+			path: "sectionId",
+			message: "Footer section was not found."
+		});
+	}
+	return ok({
+		...composition,
+		sections: composition.sections.map((section) => section.id === sectionId ? {
+			...section,
+			selected
+		} : section)
+	});
+}
+function parseFooterEngagementSection(value) {
+	const parsed = parseFooterSection(value, 0);
+	if (!parsed.ok) return parsed;
+	return parsed.value.kind === "engagement" ? ok(parsed.value) : err({
+		code: "invalid_section",
+		path: "sections.0.kind",
+		message: "Footer section must be an engagement section."
+	});
+}
+function upsertFooterEngagementSection(composition, section) {
+	const hasEngagement = composition.sections.some((candidate) => candidate.kind === "engagement");
+	return validateFooterComposition({
+		...composition,
+		sections: hasEngagement ? composition.sections.map((candidate) => candidate.kind === "engagement" ? section : candidate) : [...composition.sections, section]
+	});
+}
+function removeFooterEngagementSection(composition) {
+	return {
+		...composition,
+		sections: composition.sections.filter((section) => section.kind !== "engagement")
+	};
+}
+function repairTargetFor(section) {
+	switch (section.kind) {
+		case "brand": return { kind: "site-identity" };
+		case "navigation": return {
+			kind: "navigation",
+			role: "main"
+		};
+		case "legal-navigation": return {
+			kind: "navigation",
+			role: "legal-policy"
+		};
+		case "business-address": return { kind: "business-address" };
+		case "engagement": return {
+			kind: "engagement-source",
+			source: section.source.kind
+		};
+		case "contact":
+		case "opening-hours":
+		case "social-links": return {
+			kind: "public-profile",
+			section: section.kind
+		};
+		case "supporting-text":
+		case "legal": return {
+			kind: "footer-section",
+			sectionId: section.id
+		};
+	}
+}
+function resolveFooterSections(composition, availability) {
+	return composition.sections.filter((section) => section.selected).map((section) => isSectionRenderable(section, availability) ? {
+		kind: "renderable",
+		section
+	} : {
+		kind: "missing-source",
+		section,
+		repairTarget: repairTargetFor(section)
+	});
+}
+function isSectionRenderable(section, availability) {
+	switch (section.kind) {
+		case "brand": return section.showLogo && availability.hasLogo || section.showTitle;
+		case "navigation": return availability.hasMainNavigation;
+		case "legal-navigation": return availability.hasLegalPolicyNavigation;
+		case "business-address": return availability.hasBusinessAddress;
+		case "contact": return availability.hasContact;
+		case "opening-hours": return availability.hasOpeningHours;
+		case "social-links": return availability.hasSocialLinks;
+		case "engagement": return availability.hasEngagementSource;
+		case "supporting-text":
+		case "legal": return section.content !== null;
+	}
+}
+function deriveFooterEditorOverview(composition) {
+	return {
+		selected: composition.sections.filter((section) => section.selected).map((section) => ({
+			section,
+			status: "selected"
+		})),
+		available: composition.sections.filter((section) => !section.selected).map((section) => ({
+			section,
+			status: "available"
+		}))
+	};
+}
+const defaultSections = (legacy, options) => {
+	const footerVisible = options.footerVisible ?? true;
+	return [
+		{
+			id: unsafeAsFooterModuleId("brand"),
+			kind: "brand",
+			heading: null,
+			selected: footerVisible,
+			showLogo: options.brand?.showLogo ?? true,
+			showTitle: options.brand?.showTitle ?? true
+		},
+		{
+			id: unsafeAsFooterModuleId("navigation"),
+			kind: "navigation",
+			heading: null,
+			selected: footerVisible,
+			source: {
+				kind: "menu-role",
+				role: "main"
+			}
+		},
+		{
+			id: unsafeAsFooterModuleId("legal-navigation"),
+			kind: "legal-navigation",
+			heading: null,
+			selected: false,
+			source: {
+				kind: "menu-role",
+				role: "legal-policy"
+			}
+		},
+		{
+			id: unsafeAsFooterModuleId("business-address"),
+			kind: "business-address",
+			heading: null,
+			selected: footerVisible && legacy.showBusinessAddress === true,
+			source: { kind: "business-address" }
+		},
+		{
+			id: unsafeAsFooterModuleId("contact"),
+			kind: "contact",
+			heading: null,
+			selected: false,
+			source: { kind: "public-profile" }
+		},
+		{
+			id: unsafeAsFooterModuleId("opening-hours"),
+			kind: "opening-hours",
+			heading: null,
+			selected: false,
+			source: { kind: "public-profile" }
+		},
+		{
+			id: unsafeAsFooterModuleId("social-links"),
+			kind: "social-links",
+			heading: null,
+			selected: false,
+			source: { kind: "public-profile" }
+		},
+		{
+			id: unsafeAsFooterModuleId("supporting-text"),
+			kind: "supporting-text",
+			heading: null,
+			selected: footerVisible && isRichText(legacy.bodyText),
+			content: isRichText(legacy.bodyText) ? legacy.bodyText : null
+		},
+		{
+			id: unsafeAsFooterModuleId("legal"),
+			kind: "legal",
+			heading: null,
+			selected: footerVisible && isRichText(legacy.bottomText),
+			content: isRichText(legacy.bottomText) ? legacy.bottomText : null
+		}
+	];
+};
+function normalizeLegacyFooterContentToV1(value, options = {}) {
+	if (!isRecord$1(value)) {
+		return err({
+			code: "invalid_shape",
+			path: "",
+			message: "Legacy footer content must be an object."
+		});
+	}
+	return validateFooterComposition({
+		schemaVersion: 1,
+		sections: defaultSections(value, options)
+	});
+}
+
+//#endregion
+//#region ../core/src/footer-navigation-layout.ts
+const footerNavigationLayouts = ["stack", "inline-wrap"];
+const defaultFooterNavigationLayout = "inline-wrap";
+function normalizeFooterNavigationLayout(value) {
+	return value === "stack" ? "stack" : defaultFooterNavigationLayout;
+}
+
+//#endregion
+//#region ../core/src/number-input.ts
+/**
+* Numeric form-input parsing helpers with preserve-prev semantics on
+* NaN/empty/negative. Use these in `NumberInput.onChange` so empty input
+* doesn't silently rewrite the user's value to 0.
+*
+* The caller skips the dispatch when `null` is returned; the input box
+* keeps showing whatever the user typed (it's an uncontrolled native
+* input from React's perspective until the next state change), and the
+* dirty/saved state stays consistent.
+*/
+/**
+* Parse a `valueAsNumber` (from `<input type="number">`) into a finite
+* non-negative integer, or `null` if the value is empty / NaN / negative.
+* Fractional input is `Math.trunc`'d to an integer.
+*/
+function parseFiniteNonNegativeInt(value) {
+	if (!Number.isFinite(value)) return null;
+	if (value < 0) return null;
+	return Math.trunc(value);
+}
+/**
+* Parse a `valueAsNumber` into an integer bounded inclusive by `[min, max]`.
+* Returns `null` for out-of-range or non-finite input — same preserve-prev
+* pattern as `parseFiniteNonNegativeInt`.
+*/
+function parseBoundedInt(value, min, max) {
+	if (!Number.isFinite(value)) return null;
+	const truncated = Math.trunc(value);
+	if (truncated < min) return null;
+	if (truncated > max) return null;
+	return truncated;
+}
+
+//#endregion
+//#region ../core/src/field-errors.ts
+function clearFieldError(errors, field) {
+	const error = errors[field];
+	if (error === undefined || error.length === 0) {
+		return errors;
+	}
+	const nextErrors = { ...errors };
+	delete nextErrors[field];
+	return nextErrors;
+}
+
+//#endregion
+//#region ../core/src/form-submission-preview.ts
+const FORM_SUBMISSION_PSEUDO_FIELD_ID = "submission";
+const HIDDEN_FIELD_IDS = new Set(["form_id", "formid"]);
+const PRIORITY_IDS = new Set([
+	"name",
+	"full_name",
+	"fullname",
+	"first_name",
+	"firstname",
+	"last_name",
+	"lastname",
+	"email",
+	"email_address",
+	"emailaddress"
+]);
+const MAX_COLUMNS = 5;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSchemaField(value) {
+	return isRecord(value) && typeof value.id === "string";
+}
+function selectSubmissionPreviewFields(schemaFields, submissions) {
+	const fields = Array.isArray(schemaFields) ? schemaFields.filter(isSchemaField) : [];
+	if (!fields.length) {
+		const fallbackKeys = collectFallbackKeys(submissions);
+		return fallbackKeys.slice(0, MAX_COLUMNS).map((key) => ({
+			id: key,
+			label: humanizeSubmissionFieldKey(key),
+			type: "text"
+		}));
+	}
+	const scored = fields.map((field, index) => {
+		const id = trimmedStringOrNull(field.id);
+		if (id === null) return null;
+		const type = (field.type ?? "text").toString().toLowerCase();
+		if (shouldHideInPreview(type)) return null;
+		const label = trimmedStringOrNull(field.label?.toString()) ?? humanizeSubmissionFieldKey(id);
+		const normalizedId = id.toLowerCase();
+		const normalizedLabel = label.toLowerCase();
+		let score = 0;
+		if (PRIORITY_IDS.has(normalizedId)) score += 500;
+		if (normalizedId.includes("name") || normalizedLabel.includes("name")) score += 550;
+		if (normalizedId.includes("email") || normalizedLabel.includes("email") || type === "email") score += 450;
+		if (normalizedId.includes("phone") || normalizedLabel.includes("phone")) score += 250;
+		if (normalizedId.includes("company") || normalizedLabel.includes("company")) score += 150;
+		if (type === "select" || type === "checkbox" || type === "radio") score += 120;
+		if (field.required === true) score += 60;
+		if (hasValueInSubmissions(submissions, id)) {
+			score += 80;
+		} else {
+			score -= 40;
+		}
+		if ([
+			"richtext",
+			"textarea",
+			"longtext"
+		].includes(type)) {
+			score -= 100;
+		}
+		return {
+			id,
+			label,
+			type,
+			score,
+			index
+		};
+	}).filter((value) => value !== null);
+	scored.sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		return a.index - b.index;
+	});
+	return scored.slice(0, MAX_COLUMNS).map((item) => ({
+		id: item.id,
+		label: item.label,
+		type: item.type
+	}));
+}
+function shouldHideInPreview(type) {
+	return [
+		"textarea",
+		"richtext",
+		"markdown",
+		"longtext",
+		"html"
+	].includes(type.toLowerCase());
+}
+function hasValueInSubmissions(submissions, key) {
+	return submissions.some((row) => valueIsMeaningful(row.dataJson?.[key]));
+}
+function collectFallbackKeys(submissions) {
+	const counts = new Map();
+	submissions.forEach((row) => {
+		const data = row.dataJson;
+		if (data === null) return;
+		Object.keys(data).forEach((key) => {
+			if (HIDDEN_FIELD_IDS.has(key.toLowerCase())) return;
+			if (!counts.has(key)) counts.set(key, 0);
+			counts.set(key, (counts.get(key) ?? 0) + (valueIsMeaningful(data[key]) ? 1 : 0));
+		});
+	});
+	return Array.from(counts.entries()).sort((a, b) => {
+		if (b[1] !== a[1]) return b[1] - a[1];
+		return a[0].localeCompare(b[0]);
+	}).map(([key]) => key);
+}
+function humanizeSubmissionFieldKey(input) {
+	return input.replace(/[_\-]+/g, " ").replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").trim().replace(/^\w/, (char) => char.toUpperCase());
+}
+function valueIsMeaningful(value) {
+	if (value === null || value === undefined) return false;
+	if (typeof value === "string") return value.trim().length > 0;
+	if (Array.isArray(value)) return value.length > 0;
+	if (isRecord(value)) return Object.keys(value).length > 0;
+	return true;
+}
+function orderSubmissionFields(schemaFields, data) {
+	const result = [];
+	const seen = new Set();
+	if (schemaFields !== undefined) {
+		schemaFields.forEach((field) => {
+			const id = trimmedStringOrNull(field.id);
+			if (id === null) return;
+			if (HIDDEN_FIELD_IDS.has(id.toLowerCase())) return;
+			seen.add(id);
+			result.push({
+				id,
+				label: trimmedStringOrNull(field.label?.toString()) ?? humanizeSubmissionFieldKey(id),
+				value: data?.[id]
+			});
+		});
+	}
+	if (data !== null) {
+		Object.entries(data).forEach(([key, value]) => {
+			if (seen.has(key)) return;
+			if (HIDDEN_FIELD_IDS.has(key.toLowerCase())) return;
+			result.push({
+				id: key,
+				label: humanizeSubmissionFieldKey(key),
+				value
+			});
+		});
+	}
+	if (result.length === 0) {
+		result.push({
+			id: FORM_SUBMISSION_PSEUDO_FIELD_ID,
+			label: "Submission",
+			value: data
+		});
+	}
+	return result;
+}
+
+//#endregion
+//#region ../core/src/csv-cells.ts
+const csvEmptyCell = () => ({ kind: "empty" });
+const csvTextCell = (value) => value == null || value === "" ? csvEmptyCell() : {
+	kind: "text",
+	value
+};
+const csvIntegerCell = (value) => value == null || !Number.isFinite(value) ? csvEmptyCell() : {
+	kind: "integer",
+	value
+};
+const csvDecimalCell = (value, decimals) => value == null || !Number.isFinite(value) ? csvEmptyCell() : {
+	kind: "decimal",
+	value,
+	decimals
+};
+const csvMoneyCentsCell = (cents, currency) => {
+	const nonEmptyCurrency = asNonEmptyStringOrNull(currency);
+	return cents == null || !Number.isFinite(cents) || nonEmptyCurrency === null ? csvEmptyCell() : {
+		kind: "moneyCents",
+		cents,
+		currency: nonEmptyCurrency
+	};
+};
+const csvIsoDateCell = (value) => {
+	const nonEmptyValue = asNonEmptyStringOrNull(value);
+	return nonEmptyValue !== null ? {
+		kind: "isoDate",
+		value: nonEmptyValue
+	} : csvEmptyCell();
+};
+const csvIsoDateTimeCell = (value) => {
+	const nonEmptyValue = asNonEmptyStringOrNull(value);
+	return nonEmptyValue !== null ? {
+		kind: "isoDateTime",
+		value: nonEmptyValue
+	} : csvEmptyCell();
+};
+const csvBooleanCell = (value) => value == null ? csvEmptyCell() : {
+	kind: "boolean",
+	value
+};
+const DEFAULT_CURRENCY_MINOR_UNITS = 2;
+const CURRENCY_MINOR_UNITS = {
+	BHD: 3,
+	CLP: 0,
+	JPY: 0,
+	KWD: 3,
+	OMR: 3,
+	TND: 3
+};
+function currencyMinorUnits(currency) {
+	return CURRENCY_MINOR_UNITS[currency.trim().toUpperCase()] ?? DEFAULT_CURRENCY_MINOR_UNITS;
+}
+function formatCsvCell(cell) {
+	switch (cell.kind) {
+		case "empty": return "";
+		case "text": return cell.value;
+		case "integer": return String(cell.value);
+		case "decimal": return cell.value.toFixed(cell.decimals);
+		case "moneyCents": {
+			const minorUnits = currencyMinorUnits(cell.currency);
+			return (cell.cents / 10 ** minorUnits).toFixed(minorUnits);
+		}
+		case "isoDate":
+		case "isoDateTime": return cell.value;
+		case "boolean": return cell.value ? "true" : "false";
+	}
+}
+
+//#endregion
+//#region ../core/src/csv-date-filter.ts
+function resolveExportDateWindow(input) {
+	const basis = input.requestedBasis ?? input.policy.defaultDateBasis;
+	const supportedDateBases = input.policy.supportedDateBases;
+	if (!supportedDateBases.includes(basis)) {
+		return {
+			ok: false,
+			error: {
+				tag: "unsupported_date_basis",
+				basis,
+				exportId: input.exportId
+			}
+		};
+	}
+	const range = resolveExportDateRange(input.range, input.today ?? new Date());
+	if (!range.ok) return range;
+	if (range.window.from > range.window.to) {
+		return {
+			ok: false,
+			error: {
+				tag: "invalid_date_range",
+				from: range.window.from,
+				to: range.window.to
+			}
+		};
+	}
+	return {
+		ok: true,
+		window: {
+			basis,
+			from: range.window.from,
+			to: range.window.to,
+			timeZone: input.timeZone
+		}
+	};
+}
+function resolveExportDateRange(range, today) {
+	if (range.kind === "custom") {
+		if (typeof range.from !== "string" || range.from.length === 0 || typeof range.to !== "string" || range.to.length === 0) {
+			return {
+				ok: false,
+				error: { tag: "partial_custom_range" }
+			};
+		}
+		const from$1 = parseExportDate(range.from, "from");
+		if (!from$1.ok) return from$1;
+		const to$1 = parseExportDate(range.to, "to");
+		if (!to$1.ok) return to$1;
+		return {
+			ok: true,
+			window: {
+				from: from$1.value,
+				to: to$1.value
+			}
+		};
+	}
+	if (range.preset === "all") {
+		return {
+			ok: true,
+			window: {
+				from: unsafeAsMoneyDateString("1970-01-01"),
+				to: unsafeAsMoneyDateString(formatDate(today))
+			}
+		};
+	}
+	const days = presetDays(range.preset);
+	const to = floorUtcDate(today);
+	const from = new Date(to);
+	from.setUTCDate(from.getUTCDate() - (days - 1));
+	return {
+		ok: true,
+		window: {
+			from: unsafeAsMoneyDateString(formatDate(from)),
+			to: unsafeAsMoneyDateString(formatDate(to))
+		}
+	};
+}
+function parseExportDate(value, field) {
+	if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+		return {
+			ok: false,
+			error: {
+				tag: "invalid_date",
+				field,
+				value
+			}
+		};
+	}
+	const date = new Date(`${value}T00:00:00.000Z`);
+	if (Number.isNaN(date.getTime()) || formatDate(date) !== value) {
+		return {
+			ok: false,
+			error: {
+				tag: "invalid_date",
+				field,
+				value
+			}
+		};
+	}
+	return {
+		ok: true,
+		value: unsafeAsMoneyDateString(value)
+	};
+}
+function presetDays(preset) {
+	switch (preset) {
+		case "7d": return 7;
+		case "30d": return 30;
+		case "90d": return 90;
+		case "365d": return 365;
+	}
+}
+function floorUtcDate(date) {
+	return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+}
+function formatDate(date) {
+	return date.toISOString().slice(0, 10);
+}
+function describeExportDateBasis(basis) {
+	switch (basis) {
+		case "created_at": return "Created date";
+		case "scheduled_at": return "Scheduled date";
+		case "cancelled_at": return "Cancellation date";
+		case "paid_at": return "Payment date";
+		case "processed_at": return "Processed date";
+	}
+}
+
+//#endregion
+//#region ../core/src/csv-escape.ts
+function csvEscape(value) {
+	let s = String(value);
+	if (/^\s*[=+\-@]/.test(s)) {
+		s = `'${s}`;
+	}
+	if (s.includes(",") || s.includes("\n") || s.includes("\"")) {
+		return `"${s.replace(/"/g, "\"\"")}"`;
+	}
+	return s;
+}
+
+//#endregion
+//#region ../core/src/csv-filename.ts
+const MAX_CSV_FILENAME_LENGTH = 180;
+const CSV_EXTENSION = ".csv";
+function toSafeCsvFilename(value) {
+	const normalized = value.trim();
+	if (!normalized || /[\0\r\n/\\]/.test(normalized)) {
+		return {
+			ok: false,
+			filename: value
+		};
+	}
+	const withExtension = normalized.toLowerCase().endsWith(CSV_EXTENSION) ? normalized : `${normalized}${CSV_EXTENSION}`;
+	const filename = withExtension.length <= MAX_CSV_FILENAME_LENGTH ? withExtension : `${withExtension.slice(0, MAX_CSV_FILENAME_LENGTH - CSV_EXTENSION.length)}${CSV_EXTENSION}`;
+	return {
+		ok: true,
+		filename
+	};
+}
+function assertSafeCsvFilename(value) {
+	const result = toSafeCsvFilename(value);
+	if (!result.ok) {
+		throw new Error(`Invalid CSV filename: ${value}`);
+	}
+	return result.filename;
+}
+const unsafeCsvFilename = assertSafeCsvFilename;
+function csvFilenameDateRange(input) {
+	const from = asNonEmptyStringOrNull(input.from);
+	const to = asNonEmptyStringOrNull(input.to);
+	const range = (() => {
+		if (from !== null && to !== null) {
+			return `${from.slice(0, 10)}-to-${to.slice(0, 10)}`;
+		}
+		if (from !== null) {
+			return `from-${from.slice(0, 10)}`;
+		}
+		if (to !== null) {
+			return `to-${to.slice(0, 10)}`;
+		}
+		return input.fallback ?? "all";
+	})();
+	const prefix = asNonEmptyStringOrNull(input.prefix);
+	if (prefix !== null) {
+		return `${prefix}-${range}`;
+	}
+	return range;
+}
+function contentDispositionForCsv(filename) {
+	const asciiFallback = String(filename).replace(/[^\x20-\x7E]/g, "_").replace(/["\\]/g, "_");
+	return `attachment; filename="${asciiFallback}"; filename*=UTF-8''${encodeURIComponent(String(filename))}`;
+}
+
+//#endregion
+//#region ../core/src/csv-render.ts
+function renderCsvExport(input) {
+	const maxRows = Number(input.definition.maxRows);
+	if (input.rows.length > maxRows) {
+		return {
+			ok: false,
+			error: {
+				tag: "too_many_rows",
+				maxRows,
+				actualRows: input.rows.length
+			}
+		};
+	}
+	const filename = input.definition.filename(input.options);
+	const safeFilename = toSafeCsvFilename(String(filename));
+	if (!safeFilename.ok) {
+		return {
+			ok: false,
+			error: {
+				tag: "invalid_filename",
+				filename: safeFilename.filename
+			}
+		};
+	}
+	const columns = input.definition.columns(input.options);
+	const duplicate = findDuplicateColumnKey(columns);
+	if (duplicate !== null) {
+		return {
+			ok: false,
+			error: {
+				tag: "duplicate_column_key",
+				key: duplicate
+			}
+		};
+	}
+	const header = columns.map((column) => csvEscape(column.header)).join(",");
+	const rows = input.rows.map((row) => columns.map((column) => csvEscape(formatCsvCell(column.cell(row)))).join(","));
+	return {
+		ok: true,
+		csv: [header, ...rows].join("\n"),
+		filename: safeFilename.filename,
+		rowCount: input.rows.length,
+		sensitivities: collectCsvColumnSensitivities(columns)
+	};
+}
+function findDuplicateColumnKey(columns) {
+	const seen = new Set();
+	for (const column of columns) {
+		const key = String(column.key);
+		if (seen.has(key)) return key;
+		seen.add(key);
+	}
+	return null;
+}
+function collectCsvColumnSensitivities(columns) {
+	return new Set(columns.map((column) => column.sensitivity));
+}
+function describeRenderCsvError(error) {
+	switch (error.tag) {
+		case "too_many_rows": return `Export has ${error.actualRows} rows; narrow the filters to ${error.maxRows} rows or fewer.`;
+		case "duplicate_column_key": return `Duplicate CSV column key: ${error.key}`;
+		case "invalid_filename": return `Invalid CSV filename: ${error.filename}`;
+	}
+}
+
+//#endregion
+//#region ../core/src/csv-types.ts
+function unsafeAsCsvExportId(value) {
+	return value;
+}
+function unsafeAsCsvColumnKey(value) {
+	return value;
+}
+function asExportRowLimit(value) {
+	if (!Number.isInteger(value) || value < 1) {
+		throw new Error(`Invalid export row limit: ${value}`);
+	}
+	return value;
+}
+
+//#endregion
+//#region ../core/src/email-format.ts
+function maskEmail(email) {
+	if (email === null || email.length === 0) return null;
+	const [localPart, domain] = email.split("@");
+	if (domain === undefined || domain.length === 0 || localPart === undefined || localPart.length === 0) return email;
+	const visibleLocal = localPart.length <= 2 ? `${localPart[0] ?? ""}***` : `${localPart.slice(0, 1)}${"*".repeat(Math.max(localPart.length - 2, 1))}${localPart.slice(-1)}`;
+	return `${visibleLocal}@${domain}`;
+}
+
+//#endregion
+//#region ../core/src/slug.ts
+/**
+* Convert a string to a URL-safe slug
+*
+* @param text - The text to slugify
+* @returns URL-safe slug (lowercase, alphanumeric + hyphens)
+*
+* @example
+* slugify("Initial Consultation") // "initial-consultation"
+* slugify("90-Minute Deep Tissue") // "90-minute-deep-tissue"
+* slugify("Reiki & Energy Healing") // "reiki-energy-healing"
+*/
+function slugify(text) {
+	return text.toString().toLowerCase().trim().replace(/\s+/g, "-").replace(/[^\w\-]+/g, "").replace(/\-\-+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+/**
+* Generate a unique slug by appending a number if needed
+*
+* @param baseSlug - The base slug to make unique
+* @param existingSlugs - Array of slugs already in use
+* @returns Unique slug (adds -2, -3, etc. if needed)
+*
+* @example
+* makeUniqueSlug("consultation", ["consultation"])
+* // Returns: "consultation-2"
+*
+* makeUniqueSlug("consultation", ["consultation", "consultation-2"])
+* // Returns: "consultation-3"
+*/
+function makeUniqueSlug(baseSlug, existingSlugs) {
+	let slug = baseSlug;
+	let counter = 2;
+	while (existingSlugs.includes(slug)) {
+		slug = `${baseSlug}-${counter}`;
+		counter++;
+	}
+	return slug;
+}
+/**
+* Generate a slug from text and ensure it's unique
+*
+* @param text - The text to slugify
+* @param existingSlugs - Array of slugs already in use
+* @returns Unique URL-safe slug
+*
+* @example
+* generateUniqueSlug("Initial Consultation", ["initial-consultation"])
+* // Returns: "initial-consultation-2"
+*/
+function generateUniqueSlug(text, existingSlugs) {
+	const baseSlug = slugify(text);
+	return makeUniqueSlug(baseSlug, existingSlugs);
+}
+
+//#endregion
+//#region ../core/src/uuid.ts
+/**
+* Validates whether a string matches UUID v4 format
+* Format: 8-4-4-4-12 hexadecimal digits
+* Example: 550e8400-e29b-41d4-a716-446655440000
+*/
+function isValidUuid(str) {
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+}
+
+//#endregion
+//#region ../core/src/stable-json.ts
+function stableJsonStringify(value) {
+	return JSON.stringify(sortStableJsonValue(value));
+}
+function sortStableJsonValue(value) {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			throw new TypeError("Stable JSON only supports finite numbers");
+		}
+		return value;
+	}
+	if (Array.isArray(value)) {
+		return value.map(sortStableJsonValue);
+	}
+	if (typeof value === "object") {
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) {
+			throw new TypeError("Stable JSON only supports plain objects");
+		}
+		return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, child]) => [key, sortStableJsonValue(child)]));
+	}
+	throw new TypeError(`Stable JSON does not support ${typeof value}`);
+}
+
+//#endregion
+//#region ../core/src/secret.ts
+/**
+* Credential values that must remain inert when they cross diagnostics,
+* logging, or serialization boundaries.
+*
+* The value is deliberately held behind a non-enumerable capability rather
+* than exposed as a property. The capability uses a global symbol so a Secret
+* created by another bundled copy of core remains consumable at an approved
+* `exposeSecret` boundary.
+*/
+const SECRET_KINDS = [
+	"management-key",
+	"content-key",
+	"preview-key",
+	"webhook-secret",
+	"oauth-access-token",
+	"oauth-refresh-token",
+	"preview-session-refresh-token",
+	"oauth-authorization-code",
+	"oauth-pkce-verifier",
+	"registrar-epp-code"
+];
+const secretValueSymbol = Symbol.for("riverbank.secret.value");
+const SECRET_INSPECT_SYMBOL = Symbol.for("nodejs.util.inspect.custom");
+const MANAGEMENT_KEY_PREFIX = "bld_mgmt_sk_";
+function placeholderFor(kind) {
+	return `[riverbank:redacted:${kind}]`;
+}
+/** Create an opaque secret after a caller has parsed/validated its boundary. */
+function createSecret(kind, value) {
+	return createSecretInternal(kind, value);
+}
+/** Construct a Secret for an already validated kind/value pair. */
+function createSecretInternal(kind, value) {
+	const placeholder = placeholderFor(kind);
+	const secret = {
+		kind: "secret",
+		secretType: kind,
+		toString: () => placeholder,
+		toJSON: () => placeholder,
+		[SECRET_INSPECT_SYMBOL]: () => placeholder
+	};
+	Object.defineProperty(secret, secretValueSymbol, {
+		configurable: false,
+		enumerable: false,
+		value: () => value,
+		writable: false
+	});
+	return Object.freeze(secret);
+}
+/**
+* Parse an untrusted management API key before constructing its Secret value.
+*
+* The Secret type protects an already validated value from accidental
+* disclosure; this boundary is what validates the value's wire format.
+*/
+function parseManagementKey(raw) {
+	if (typeof raw !== "string" || !raw.startsWith(MANAGEMENT_KEY_PREFIX) || raw.length === MANAGEMENT_KEY_PREFIX.length) {
+		return err({ kind: "invalid-management-key" });
+	}
+	return ok(createSecretInternal("management-key", raw));
+}
+/**
+* The only generic plaintext exposure operation. Keep calls at named I/O
+* boundaries; do not pass exposed strings through domain/application layers.
+*/
+function exposeSecret(secret) {
+	const getValue = secret[secretValueSymbol];
+	if (typeof getValue !== "function") return failInvalidSecret();
+	return getValue();
+}
+function failInvalidSecret() {
+	throw new TypeError("Invalid Riverbank secret");
+}
+
+//#endregion
+//#region ../core/src/site-route-target.ts
+const SITE_ROUTE_NODE_TYPES = [
+	"page",
+	"content_entry",
+	"page_surface"
+];
+function parseSiteRouteTarget(input) {
+	if (typeof input.nodeType !== "string") {
+		return err({
+			kind: "invalid-node-type",
+			nodeType: input.nodeType
+		});
+	}
+	switch (input.nodeType) {
+		case "page": {
+			const pageId = parsePageId(input.nodeId);
+			return pageId.ok ? ok({
+				kind: "page",
+				pageId: pageId.value
+			}) : err({
+				kind: "invalid-page-id",
+				error: pageId.error
+			});
+		}
+		case "content_entry": {
+			const entryId = parseContentEntryId(input.nodeId);
+			return entryId.ok ? ok({
+				kind: "contentEntry",
+				entryId: entryId.value
+			}) : err({
+				kind: "invalid-content-entry-id",
+				error: entryId.error
+			});
+		}
+		case "page_surface": {
+			const surfaceId = parsePageSurfaceId(input.nodeId);
+			return surfaceId.ok ? ok({
+				kind: "pageSurface",
+				surfaceId: surfaceId.value
+			}) : err({
+				kind: "invalid-page-surface-id",
+				error: surfaceId.error
+			});
+		}
+		default: return err({
+			kind: "unsupported-node-type",
+			nodeType: input.nodeType
+		});
+	}
+}
+function siteRouteTargetNodeType(target) {
+	switch (target.kind) {
+		case "page": return "page";
+		case "contentEntry": return "content_entry";
+		case "pageSurface": return "page_surface";
+		default: return assertNever(target);
+	}
+}
+function foldSiteRouteTarget(target, cases) {
+	switch (target.kind) {
+		case "page": return cases.page(target.pageId);
+		case "contentEntry": return cases.contentEntry(target.entryId);
+		case "pageSurface": return cases.pageSurface(target.surfaceId);
+		default: return assertNever(target);
+	}
+}
+
+//#endregion
+//#region ../core/src/planner.ts
+function plannerNoChange(details = {}) {
+	return {
+		...details,
+		tag: "no_change"
+	};
+}
+function plannerUpdate(details = {}) {
+	return {
+		...details,
+		tag: "update"
+	};
+}
+/** Identity at runtime; marks a planner-derived patch as shallow readonly. */
+function plannerPatch(patch) {
+	return patch;
+}
+/** Default clock for production callers that do not inject time explicitly. */
+const systemPlanningClock = { now: () => Date.now() };
+/** Resolve current time from an explicit timestamp, injected clock, or system clock. */
+function resolvePlanningNow(input = {}) {
+	if (typeof input.now === "number") {
+		return input.now;
+	}
+	return (input.clock ?? systemPlanningClock).now();
+}
+/** Resolve current time as a Date from an explicit Date, injected clock, or system clock. */
+function resolvePlanningNowDate(input = {}) {
+	if (input.now !== undefined) {
+		return input.now;
+	}
+	return new Date((input.clock ?? systemPlanningClock).now());
+}
+/**
+* Resolve a Date-compatible planner input.
+*
+* Precedence: bare Date, `{ now }`, `{ clock }`, then `systemPlanningClock`.
+* Explicit Date inputs are returned by reference, not cloned.
+*/
+function resolvePlanningDateInput(input = {}) {
+	if (input instanceof Date) {
+		return input;
+	}
+	return resolvePlanningNowDate(input);
+}
+/** Build an enabled selection while preserving literal value types. */
+function enabledSelection(value) {
+	return {
+		enabled: true,
+		value
+	};
+}
+/** Build a disabled selection. */
+function disabledSelection() {
+	return { enabled: false };
+}
+
+//#endregion
+export { unsafeAsDetectedMimeType as $, parseUtcIsoDateTimeString as A, formatCurrencyAmount as B, formatBookingDateParts as C, getBookingLocalDateKey as D, formatLocalScheduleTime as E, parseEventPageSurfaceSubject as F, parsePageId as G, parseApiKeyId as H, formatBookingPriceDisplay as I, unsafeAsAppointmentResourceId as J, parseSiteId as K, formatEventPricing as L, toScheduledBookingDateRange as M, toScheduledBookingDateTime as N, getLocalScheduleDate as O, parseBookingTimeZone as P, unsafeAsDemoCapability as Q, publicEventPricingCurrency as R, formatBookingDate as S, formatLocalScheduleDate as T, parseEventSeriesId as U, assertNever as V, parseMediaAssetId as W, unsafeAsBookingSessionId as X, unsafeAsBookingRequirementId as Y, unsafeAsDeclaredMimeType as Z, mapNonEmptyArray as _, unsafeAsUploadSessionId as _t, stableJsonStringify as a, unsafeAsOccurrenceId as at, normalizeLocationAddressText as b, ok as bt, parseFooterModuleId as c, unsafeAsPositiveSeconds as ct, parseNewsletterListId as d, unsafeAsSiteFontId as dt, unsafeAsEntitlementId as et, parseNewsletterSignupAuthoringDestinationValue as f, unsafeAsSiteId as ft, fromArray as g, unsafeAsStoragePath as gt, assertAllowedPublicUrl as h, unsafeAsStorageBucketName as ht, parseManagementKey as i, unsafeAsMediaAssetId as it, toBookingTimeZone as j, getLocalScheduleTime as k, parseMailchimpAudienceId as l, unsafeAsProductId as lt, isCanonicalRichTextDoc as m, unsafeAsStaffMemberId as mt, createSecret as n, unsafeAsEventSeriesId as nt, footerNavigationLayouts as o, unsafeAsOriginalFilename as ot, parseNewsletterSignupDestinationProvider as p, unsafeAsSiteScopedStoragePath as pt, parseUserId as q, exposeSecret as r, unsafeAsFileChecksumSha256 as rt, parseFooterCompositionV1 as s, unsafeAsPositiveByteCount as st, resolvePlanningDateInput as t, unsafeAsEventOfferingId as tt, parseMailchimpTagName as u, unsafeAsSafeDownloadFilename as ut, hasText as v, unsafeAsUserId as vt, formatBookingTime as w, toLocationCoordinates as x, isPresent as y, err as yt, publicEventPricingType as z };