riverbankcms 0.22.0 → 0.22.2

package/dist/cli/index.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { $ as createNavigationRef, $n as cardRoleSchema, $r as __toESM, A as eventManagementTiming, An as runtimeMediaSchema, Ar as backgroundColorStyle, At as BREAKPOINT_SM, B as bookingPaymentCollectionOptionSchema, Bn as deriveVideoSlotPolicy, Br as PUBLIC_BUTTON_ROLES, Bt as themeButtonSizeClassName, C as stableStringify, Cn as getDirectImageUrlForRelativePath, Cr as tileTreatmentValues, Ct as themeSchema, Dn as mediaPosterSchema, Dr as surfaceDecorationColors, Dt as renderHeaderPaintTargetRules, E as mapEventCommandContent, En as isSiteScopedDirectImageStoragePath, Er as resolveSurface, Et as getHeaderPaintTargets, F as pageIdentifierForCommand, Fn as buildMediaIdentifierFromFilename, Fr as opaqueSurfaceDeclarations, Ft as getComponentShadowVar, G as createBlockRef, Gr as surfaceForegroundInputFromResolved, Gt as buildTextContrastShadow, H as require_jsx_runtime, Hr as surfaceToneFromForegroundToken, Ht as parseThemeForPersistence, I as pagePathForCommand, In as parseCanonicalMediaIdentifier, Ir as isCssColorLiteral, It as ICON_CONFIG, J as createContentEntryRef, Jr as expandPalette, Jt as arrangementSlotNames, K as createBlocksRef, Kn as parseRelativeStoragePath, Kr as surfaceForegroundStyle, Kt as generateNavLinkCSS, L as hasConfiguredBookingVertical, Ln as parseMediaIdentifier, Lr as resolveOnColorForThemeToken, Lt as generateDefaultButtonSystem, M as blockOrderIdentifiersForCommand, Mn as resolveManagedMediaReference, Mr as mergeStyles, Mt as MQ_MD_DOWN, N as entryIdentifierForCommand, Nn as mediaTypeDiscriminants, Nr as rgbColorValue, Nt as headerVariantValues, On as mediaSchema, Or as resolveSurfaceForeground, Ot as BREAKPOINT_LG, P as pageIdentifierForBlockCommand, Pn as mediaIdentifierSchema, Pr as textColorStyle, Pt as getComponentBorderWidthPx, Q as createFormRef, Qn as renderCssDeclarations, Qr as __commonJSMin, R as eventCommandScheduleSchema, Rr as resolveThemeColorReferenceValue, Rt as parseThemeButtonVariantId, S as sortRecord, Sn as resolveMediaTransformForAspect, Sr as testimonialsCompositionTreatmentValues, St as deriveSiteStyleBlockPolicy, Tn as getImageUrl, Tr as visibleHeadingDecorationFamilyValues, Tt as generateMobileOverlayBackdropFilterFix, U as require_react, Un as getMimeType, Ur as defaultThemeTokens, V as bookingPaymentTermsSchema, Vn as resolveVideoSelectionIntentForMediaField, Vr as selectLogoVariant, Vt as themeButtonVariantClassNames, W as ianaTimezoneSchema, Wn as asRecord, Wr as surfaceForegroundDeclarations, Wt as footerForegroundCandidates, X as createEventSeriesRef, Xn as managementMediaLibraryUploadLimitForMimeType, Xr as parseThemeColorToken, Xt as resolveLookSlotSurfaces, Y as createEventCategoryRef, Yn as classifyKnownMimeType, Yr as getTextColorForBackground, Yt as resolveItemSurface, Z as createFooterRef, Zn as parseSafeDownloadFilename, Zr as parseBlockColorToken, _n as looksLikeUuid, _r as featureCardCompositionTreatmentValues, _t as requireCuratedSiteStyle, an as parseCanonicalRuntimeBackground, ar as cardListKnobBlocks, at as effectiveHeaderNavLinkStyle, b as isEventVisibility, bn as isExplicitRectCrop, br as makeBoundaryId, bt as getGradientPreset, c as customLinkSchema$1, cn as boxBackgroundOverlaySchema, cr as asLayoutVariantKey, ct as transparentHeaderForegroundInput, d as internalLinkSchema, dn as siteChromeBackgroundOverrideOwner, dr as assertNever$11, dt as readHeaderNavFontSizePreference, en as headerRootPaint, er as cardVariantRoleValues, et as createPageRef, f as internalResolvedLinkSchema, fn as stripStaleTransitionStyleGroup, fr as defineBlockDesignCapability, ft as arrangementManifestFromVariants, g as linkSchema, gn as deleteEnvSpecificKeys, gr as eyebrowTreatmentValues, gt as resolvePublishedLook, h as isResolvedInternalLinkEntityType, hn as walkAndCollectImageAttrs, hr as eventListTreatmentValues, ht as resolveModeArrangement, in as deriveSectionGround, ir as cardListFamilyBlocks, j as blockIdentifierForCommand, jn as buildRenderableMediaAssetIndex, jr as borderColorStyle, jt as BREAKPOINT_XL, kn as persistableMediaSchema, kr as TokenResolver, kt as BREAKPOINT_MD, l as entryLinkSchema$1, ln as boxBackgroundSchema, lt as readOpeningForegroundProjection, mn as summarizePortableMediaReferences, mr as defineNoBlockDesignCapability, mt as resolveEffectiveArrangement, nn as composeBoundary, nr as defineBlockDesignMetadata, nt as createVenueRef, o as classifySdkEventBookingOffer, on as resolveSectionBackground, ot as headerForegroundCandidates, p as internalRouteOnlyLinkSchema, pn as collectPortableMediaReferencesFromContent, pr as defineFrameCapability, pt as readStoredMode, q as createCommandRef, qn as FILE_SIZE_LIMITS, qr as surfaceForegroundValue, qt as arrangementLookHooks, rn as sectionFactsForContent, rr as resolveEffectiveKnobs, rt as refSlug, s as RESOLVED_INTERNAL_LINK_ENTITY_TYPES, sn as resolveSectionPhotoPlacement, sr as asDesignBlockId, st as headerLeafTextColor, t as classifySdkEventTiming, tn as boundaryLayout, tr as normalizeCardRole, u as externalLinkSchema$1, un as runtimeBoxBackgroundSchema, ur as asSiteStyleId, ut as mergeHeaderNavTypographyPreference, v as pageLinkSchema$1, vn as rotateNormalizedPoint, vr as headingDecorationColorTokenValues, vt as compiledRuntimeStyleFieldNames, wn as getDirectImageUrlForSiteScopedPath, wr as toNonEmptyReadonlyArray, wt as generateHeaderScrollTreatmentStyles, x as venueManagementFields, xn as parseAspectRatioValue, xr as offeringsPreviewCompositionTreatmentValues, xt as parseGradientPresetId, yn as normalizeWidthCandidates, yr as introCompositionTreatmentValues, yt as gradientToCss, zr as resolveTokenOrCssColorValue, zt as themeButtonExtraClassesWithTrailingIcon } from "../sdk-event-upsert-BqjzK2zT.mjs";
-import { $ as compareLocalScheduleDates, $t as parseCustomerId, A as DEFAULT_MAILING_LIST_SUCCESS_MESSAGE, At as formatEventPricing, Bn as ok, Bt as mapReadonlyNonEmptyArray, Cn as unsafeAsOccurrenceId, Ct as omitZeroAmountFutureRows, D as parseMailingListSignedSourceToken, Dt as deriveTotalTicketQuantity, E as parseMailingListContentVersionId, En as unsafeAsPositiveByteCount, Et as resolveFlexibleBalanceInitialPaymentCents, F as DEFAULT_MAILING_LIST_TARGETING, Ft as publicEventPricingType, G as formatDateRange, Gt as toNonNegativeCents, H as toLocationCoordinates, Ht as parseNonNegativeCents, I as planMailingListChoicePresentation, It as resolveExactOrFreePriceDisplay, J as formatTime$1, Jt as formatCurrencyAmount, K as formatDateTime, Kt as unsafeAsNonNegativeCents, L as isCanonicalRichTextDoc, Lt as resolvePricingOptionsPriceDisplay, M as parseFooterCompositionV1, Mt as publicEventPricingCurrency, Nt as publicEventPricingDisplay, O as parseMailingListRuntimeContext, On as unsafeAsPricingOptionId, Ot as parseEventPageSurfaceSubject, P as parseMailingListPlacementTargeting, Pt as publicEventPricingOptions, Q as buildBookingUtcDateWindow, Qt as parseApiKeyId, Rt as fromArray, S as parseManagementKey, Sn as unsafeAsMediaAssetId, St as getBookingInstalmentProtectedDepositAmountCents, T as parseMailingListBlockId, Tn as unsafeAsPassId, Tt as resolveFlexibleBalanceDueAt, U as selectCategoryView, Ut as parsePositiveCents, V as normalizeLocationAddressText, Vt as isNonNegativeWholeCents$1, W as formatDate, Wt as toCents, X as inferSiteDateLocale, Xt as assertNever, Y as formatTimeRange, Yt as parseCurrencyCode, Z as resolveBookingDisplayContext, Zt as formatDurationUnitLabel, _ as orderedLiveRunSessions, _t as isSettleableOrderInstalmentPlanStatus, b as createSecret, bt as getBookingInstalmentDepositRefundability, c as resolveSiteVerticalBookingConfig, cn as parseSiteTermsVersionId, ct as resolveBookingBusinessTimeZone, dt as toScheduledBookingDateTime, en as parseDatedOfferingCapacityHoldAuditRef, et as formatLocalScheduleDate, f as SURFACE_EVENT_PRESET_VALUES, ft as toUtcIsoDateTimeString, g as nextLiveRunSessionStartMs, gt as isSettleableFlexibleBalanceContractStatus, h as CANCELLED_SESSION_STATUS, hn as unsafeAsDemoCapability, ht as isLiveOrderInstalmentPlanStatus, in as parseMembershipId, it as getLocalScheduleTime, j as parseMailingListProviderScope, jt as isPublicEventPricingOptionDisplayable, k as assessMailingListTargeting, kt as formatBookingPriceDisplay, ln as parseUserId, lt as resolveBookingTimeZoneId, mt as validateBookingPaymentOptionKinds, n as EVENT_PRESET_VOCABULARY, nn as parseEventSeriesId, nt as getBookingLocalDateKey, on as parseRetiredCourseId, ot as parseBookingLocalDate, p as WHOLE_SERIES_EVENT_PRESET_VALUES, pn as unsafeAsCheckoutLineId, q as formatDateTimeRange, qt as unsafeAsPositiveCents, r as NAVIGATION_LOCATIONS, rt as getLocalScheduleDate, sn as parseSiteId, st as parseUtcIsoDateTimeString, tn as parseDatedOfferingCapacityHoldId, tt as formatLocalScheduleTime, u as EVENT_PRESET_VALUES, ut as toBookingTimeZone, v as resolveWholeSeriesBookingPhase, vn as unsafeAsEventInstanceId, vt as addIntervalPreservingMonthAnchor, w as slugify, wt as splitAmountWithRemainderInFirst, x as exposeSecret, xt as getBookingInstalmentPlanIntervalCount, y as resolveWholeSeriesRunLifecycle, yt as clampConfiguredAmount, z as assertAllowedPublicUrl, zn as err } from "../src-zzwJUef5.mjs";
-import { $ as buildStorageUrl, $t as createClientForEnv, A as formatDiffDetail, At as convertPulledFooterToLocal, B as formatFieldPath, Bn as linkPayloadSchema, Bt as extractApiErrorMessage, C as reportFromOutcomes, Cn as planEnvironmentWriteAuthorization, Ct as readJsonFile, D as normalizeRemoteHomepageReference, Dn as formatError, Dt as duplicateNavigationIdentityMessage, E as createEmptySyncResult, En as ErrorCodes, Et as isMediaValue, F as calculatePullDiff, Fn as loadSdkEnvironment, Ft as applyPushConfigPlan, G as prepareLocalMediaForPush, Gt as createBearerAPIClient, Hn as sdkConfiguredBookingVerticalConfigSchema, Ht as isRecord$2, I as buildJsonDiff, In as createManagementClient, It as createPushConfigCommand, J as writeBinaryFileAtomic, Jt as deriveCmsApiUrlFromDashboardUrl, K as admitBinaryWriteDestination, Kt as ApiEnvelopeError, Ln as ManagementApiError, Lt as loadPushConfigTarget, M as hasPendingChanges, Mn as getEnvironmentDebugInfo, Mt as convertPulledPagesToLocal, N as findChangedFieldsWithValues, Nn as isLocalConfigured, Nt as navigationCommandItemToManagementInput, O as calculateDiff, On as transportSuggestion, Ot as navigationIdentity, P as formatHumanDiff, Pn as isRemoteConfigured, Pt as normalizeNavigationConfigItemForCommand, Q as walkLocalContentMedia, Qt as confirmAction, R as buildFieldChanges, Rn as sdkEventScheduleSchema, Rt as preparePushConfigTarget, S as planCliCommandBatchForBindings, Sn as planEnvironmentExecution, St as listFiles, T as executeResidualSettingsSyncPlan, Tn as withRiverbankEnv, Tt as writeJsonFileAtomic, U as syncLocalMediaForPull, Ut as APPOINTMENT_SERVICE_VISIBILITY_VALUES, V as revalidateLocalMediaPushPlan, Vn as portablePageDesignSchema, Vt as normalizeApiError, W as applyLocalMediaPush, Wt as ApiRequestError, X as normalizeMediaIdentifierInput, Xt as mapEnvironmentExecutionOutcomesJson, Y as sha256, Yt as API_ENDPOINTS, Z as normalizeMediaValueToIdentifierOnly, Zt as bindRequestTimeout, _ as commandExecutionToReport, _n as withConfirmation, _t as readMetadataFile, a as executeEntryCommandPlanAsReport, an as formatDateShort, at as readEventCategoriesMeta, b as executeCompiledCliCommandPlanAsReport, bn as executeEnvironmentPlan, bt as ensureDir, c as titleFromEntryData, cn as handleCommandError, ct as readFormsMeta, d as unsafeAsCliEntryIdentifier, dn as parseJsonArray, dt as readSettingsMeta, en as createCommandContext, et as downloadMedia, f as unsafeAsCliFormSlug, fn as parseJsonData, ft as readVenuesMeta, g as commandCompileFailureToReport, gn as withCommandContext, gt as metadataTargetFromEnvironment, h as mutationCounterForEffect, hn as runWithInvocation, ht as metadataFilePath, i as entrySiteCommandTypes, in as currentInvocationEnvelope, it as readAllMeta, j as formatDiffSummary, jn as getEnvPrefix, jt as convertPulledNavigationToLocal, k as calculateFooterDiff, kn as CliExit, kt as navigationIdentityMap, l as unsafeAsCliBlockIdentifier, ln as managementClientConfigFor, lt as readNavigationMeta, m as commandReportToSyncResult, mn as resolveCommandPath, mt as ensureMetadataDir, n as entryCommandCompileErrorToReport, nn as createListCommand, nt as findLegacyEntryFiles, o as executeEntryCommandPlanAsSyncResult, on as getOutputContext, ot as readEventsMeta, p as unsafeAsCliPageIdentifier, pn as parsePaginationOptions, pt as writeMediaManifest, q as readStableBinaryFile, qt as unwrapResponse, r as entryCommandReportToSyncResult, rn as createOutputForCommand, rt as readEntries, s as syncResultForEntryCommandCompileError, sn as getOutputOnlyContext, st as readFooterMeta, t as compileEntryPushCommands, tn as createGetCommand, tt as extractMediaIdentifiers, u as unsafeAsCliContentTypeKey, un as mapEntryForOutput, ut as readPagesMeta, v as commandReportHasFailures, vn as withErrorHandling, vt as writeMetadataFile, w as mergeManySyncResults, wn as requireEnvironmentWriteAuthorization, wt as writeJsonFile, x as formatManagementError, xn as parseEnvironmentSelection, xt as fileExists, y as executeCliCommandPlan, yn as withOutputOnlyErrorHandling, yt as writeMetadataRecordMap, z as formatFieldChange, zn as sdkSettingsUpdateSchema, zt as revalidatePushConfigPlan } from "../entryCommands-CoGu0G2R.mjs";
-import { r as CLI_VERSION, t as loadConfigFile } from "../load-config-j58KSqxl.mjs";
-import { a as RichTextDocSchema, c as isRecord$18, i as findUnfilledSentinels, n as buildEntryScaffold, o as isRichTextDoc, r as validateEntryInstance, s as isObjectRecord, t as eventUpsertInputSchema } from "../eventUpsertInputSchema-B0ubhUu5.mjs";
-import { a as prepareScaffoldExecution, c as LOCAL_PACKAGE_VENDOR_DIR, d as loadGeneratedPackageRanges, i as preflightScaffoldTargets, n as createScaffoldCompletion, s as deriveScaffoldLocalManifest, t as deriveScaffoldPlan } from "../plan-C4IphkPc.mjs";
+import { $ as createFormRef, $n as managementMediaLibraryUploadLimitForMimeType, $r as parseThemeColorToken, An as mediaPosterSchema, Ar as surfaceDecorationColors, At as BREAKPOINT_MD, Bn as parseMediaIdentifier, Br as resolveOnColorForThemeToken, Bt as themeButtonExtraClassesWithTrailingIcon, C as sortRecord, Cn as isExplicitRectCrop, Cr as makeBoundaryId, Ct as deriveSiteStyleBlockPolicy, D as mapEventCommandContent, Dn as getDirectImageUrlForSiteScopedPath, Dr as toNonEmptyReadonlyArray, Dt as getHeaderPaintTargets, En as getDirectImageUrlForRelativePath, Er as tileTreatmentValues, Et as generateMobileOverlayBackdropFilterFix, F as pageIdentifierForBlockCommand, Fn as resolveManagedMediaReference, Fr as mergeStyles, Ft as getComponentBorderWidthPx, G as ianaTimezoneSchema, Gr as surfaceToneFromForegroundToken, Gt as footerForegroundCandidates, H as bookingPaymentTermsSchema, Hr as resolveTokenOrCssColorValue, Ht as themeButtonVariantClassNames, I as pageIdentifierForCommand, In as mediaTypeDiscriminants, Ir as rgbColorValue, It as getComponentShadowVar, J as createCommandRef, Jr as surfaceForegroundInputFromResolved, Jt as arrangementLookHooks, K as createBlockRef, Kn as getMimeType, Kr as defaultThemeTokens, Kt as buildTextContrastShadow, L as pagePathForCommand, Ln as mediaIdentifierSchema, Lr as textColorStyle, Lt as ICON_CONFIG, M as blockIdentifierForCommand, Mn as persistableMediaSchema, Mr as TokenResolver, Mt as BREAKPOINT_XL, N as blockOrderIdentifiersForCommand, Nn as runtimeMediaSchema, Nr as backgroundColorStyle, Nt as MQ_MD_DOWN, On as getImageUrl, Or as visibleHeadingDecorationFamilyValues, Ot as renderHeaderPaintTargetRules, P as entryIdentifierForCommand, Pn as buildRenderableMediaAssetIndex, Pr as borderColorStyle, Pt as headerVariantValues, Q as createFooterRef, Qn as classifyKnownMimeType, Qr as getTextColorForBackground, R as hasConfiguredBookingVertical, Rn as buildMediaIdentifierFromFilename, Rr as opaqueSurfaceDeclarations, Rt as generateDefaultButtonSystem, S as venueManagementFields, Sn as normalizeWidthCandidates, Sr as introCompositionTreatmentValues, St as parseGradientPresetId, Tn as resolveMediaTransformForAspect, Tr as testimonialsCompositionTreatmentValues, Tt as generateHeaderScrollTreatmentStyles, U as require_jsx_runtime, Un as deriveVideoSlotPolicy, Ur as PUBLIC_BUTTON_ROLES, Ut as parseThemeForPersistence, V as bookingPaymentCollectionOptionSchema, Vr as resolveThemeColorReferenceValue, Vt as themeButtonSizeClassName, W as require_react, Wn as resolveVideoSelectionIntentForMediaField, Wr as selectLogoVariant, X as createEventCategoryRef, Xn as FILE_SIZE_LIMITS, Xr as surfaceForegroundValue, Xt as resolveItemSurface, Y as createContentEntryRef, Yn as parseRelativeStoragePath, Yr as surfaceForegroundStyle, Yt as arrangementSlotNames, Z as createEventSeriesRef, Zr as expandPalette, Zt as resolveLookSlotSurfaces, _n as summarizePortableMediaReferences, _r as defineNoBlockDesignCapability, _t as resolvePublishedLook, an as deriveSectionGround, ar as defineBlockDesignMetadata, b as isEventVisibility, bn as looksLikeUuid, br as featureCardCompositionTreatmentValues, bt as gradientToCss, c as customLinkSchema$1, cn as resolveSectionBackground, cr as cardListKnobBlocks, ct as headerLeafTextColor, d as internalLinkSchema, dn as boxBackgroundOverlaySchema, dr as asLayoutVariantKey, dt as mergeHeaderNavTypographyPreference, ei as parseBlockColorToken, er as parseSafeDownloadFilename, et as createNavigationRef, f as internalResolvedLinkSchema, fn as boxBackgroundSchema, ft as readHeaderNavFontSizePreference, g as linkSchema, gn as collectPortableMediaReferencesFromContent, gr as defineFrameCapability, gt as resolveModeArrangement, h as isResolvedInternalLinkEntityType, hn as stripStaleTransitionStyleGroup, hr as defineBlockDesignCapability, ht as resolveEffectiveArrangement, in as sectionFactsForContent, ir as normalizeCardRole, it as refSlug, j as eventManagementTiming, jn as mediaSchema, jr as resolveSurfaceForeground, jt as BREAKPOINT_SM, kn as isSiteScopedDirectImageStoragePath, kr as resolveSurface, kt as BREAKPOINT_LG, l as entryLinkSchema$1, ln as resolveSectionPhotoPlacement, lt as transparentHeaderForegroundInput, mn as siteChromeBackgroundOverrideOwner, mr as assertNever$11, mt as readStoredMode, ni as __toESM, nn as boundaryLayout, nr as cardRoleSchema, o as classifySdkEventBookingOffer, on as heroPhotoPaintsGround, or as resolveEffectiveKnobs, ot as effectiveHeaderNavLinkStyle, p as internalRouteOnlyLinkSchema, pn as runtimeBoxBackgroundSchema, pr as asSiteStyleId, pt as arrangementManifestFromVariants, q as createBlocksRef, qn as asRecord, qr as surfaceForegroundDeclarations, qt as generateNavLinkCSS, rn as composeBoundary, rr as cardVariantRoleValues, rt as createVenueRef, s as RESOLVED_INTERNAL_LINK_ENTITY_TYPES, sn as parseCanonicalRuntimeBackground, sr as cardListFamilyBlocks, st as headerForegroundCandidates, t as classifySdkEventTiming, ti as __commonJSMin, tn as headerRootPaint, tr as renderCssDeclarations, tt as createPageRef, u as externalLinkSchema$1, un as sectionForegroundBackground, ur as asDesignBlockId, ut as readOpeningForegroundProjection, v as pageLinkSchema$1, vn as walkAndCollectImageAttrs, vr as eventListTreatmentValues, vt as requireCuratedSiteStyle, w as stableStringify, wn as parseAspectRatioValue, wr as offeringsPreviewCompositionTreatmentValues, wt as themeSchema, xn as rotateNormalizedPoint, xr as headingDecorationColorTokenValues, xt as getGradientPreset, yn as deleteEnvSpecificKeys, yr as eyebrowTreatmentValues, yt as compiledRuntimeStyleFieldNames, z as eventCommandScheduleSchema, zn as parseCanonicalMediaIdentifier, zr as isCssColorLiteral, zt as parseThemeButtonVariantId } from "../sdk-event-upsert-zWw5VolM.mjs";
+import { $ as resolveBookingDisplayContext, $t as assertNever, A as DEFAULT_MAILING_LIST_SUCCESS_MESSAGE, At as deriveTotalTicketQuantity, B as parseWeeklyOpeningHours, Bt as resolvePricingOptionsPriceDisplay, Ct as getBookingInstalmentDepositRefundability, D as parseMailingListSignedSourceToken, Dt as splitAmountWithRemainderInFirst, E as parseMailingListContentVersionId, En as unsafeAsOccurrenceId, Et as omitZeroAmountFutureRows, F as DEFAULT_MAILING_LIST_TARGETING, Ft as publicEventPricingCurrency, G as selectCategoryView, Gt as parseNonNegativeCents, Hn as err, I as planMailingListChoicePresentation, It as publicEventPricingDisplay, J as formatDateTime, Jt as toNonNegativeCents, K as formatDate, Kt as parsePositiveCents, L as isCanonicalRichTextDoc, Lt as publicEventPricingOptions, M as parseFooterCompositionV1, Mt as formatBookingPriceDisplay, Nt as formatEventPricing, O as parseMailingListRuntimeContext, On as unsafeAsPassId, Ot as resolveFlexibleBalanceDueAt, P as parseMailingListPlacementTargeting, Pt as isPublicEventPricingOptionDisplayable, Q as inferSiteDateLocale, Qt as parseCurrencyCode, R as formatOpeningHoursRows, Rt as publicEventPricingType, S as parseManagementKey, St as clampConfiguredAmount, T as parseMailingListBlockId, Tn as unsafeAsMediaAssetId, Tt as getBookingInstalmentProtectedDepositAmountCents, U as normalizeLocationAddressText, Un as ok, Ut as mapReadonlyNonEmptyArray, V as assertAllowedPublicUrl, Vt as fromArray, W as toLocationCoordinates, Wt as isNonNegativeWholeCents$1, X as formatTime$1, Xt as unsafeAsPositiveCents, Y as formatDateTimeRange, Yt as unsafeAsNonNegativeCents, Z as formatTimeRange, Zt as formatCurrencyAmount, _ as orderedLiveRunSessions, _t as validateBookingPaymentOptionKinds, an as parseEventSeriesId, at as getLocalScheduleDate, b as createSecret, bt as isSettleableOrderInstalmentPlanStatus, c as resolveSiteVerticalBookingConfig, ct as parseBookingLocalDate, dn as parseSiteTermsVersionId, dt as resolveBookingBusinessTimeZone, en as formatDurationUnitLabel, et as buildBookingUtcDateWindow, f as SURFACE_EVENT_PRESET_VALUES, fn as parseUserId, ft as resolveBookingTimeZoneId, g as nextLiveRunSessionStartMs, gn as unsafeAsCheckoutLineId, h as CANCELLED_SESSION_STATUS, ht as toUtcIsoDateTimeString, in as parseDatedOfferingCapacityHoldId, it as getBookingLocalDateKey, j as parseMailingListProviderScope, jn as unsafeAsPricingOptionId, jt as parseEventPageSurfaceSubject, k as assessMailingListTargeting, kn as unsafeAsPositiveByteCount, kt as resolveFlexibleBalanceInitialPaymentCents, ln as parseRetiredCourseId, lt as parseLocalScheduleTime, mt as toScheduledBookingDateTime, n as EVENT_PRESET_VOCABULARY, nn as parseCustomerId, nt as formatLocalScheduleDate, ot as getLocalScheduleTime, p as WHOLE_SERIES_EVENT_PRESET_VALUES, pt as toBookingTimeZone, q as formatDateRange, qt as toCents, r as NAVIGATION_LOCATIONS, rn as parseDatedOfferingCapacityHoldAuditRef, rt as formatLocalScheduleTime, sn as parseMembershipId, tn as parseApiKeyId, tt as compareLocalScheduleDates, u as EVENT_PRESET_VALUES, un as parseSiteId, ut as parseUtcIsoDateTimeString, v as resolveWholeSeriesBookingPhase, vn as unsafeAsDemoCapability, vt as isLiveOrderInstalmentPlanStatus, w as slugify, wt as getBookingInstalmentPlanIntervalCount, x as exposeSecret, xn as unsafeAsEventInstanceId, xt as addIntervalPreservingMonthAnchor, y as resolveWholeSeriesRunLifecycle, yt as isSettleableFlexibleBalanceContractStatus, zt as resolveExactOrFreePriceDisplay } from "../src-ZACBG29u.mjs";
+import { $ as normalizeMediaValueToIdentifierOnly, $t as bindRequestTimeout, A as formatDiffDetail, An as transportSuggestion, At as navigationIdentity, B as buildFieldChanges, Bn as sdkEventScheduleSchema, Bt as preparePushConfigTarget, C as reportFromOutcomes, Cn as parseEnvironmentSelection, Ct as fileExists, D as normalizeRemoteHomepageReference, Dn as withRiverbankEnv, Dt as writeJsonFileAtomic, E as createEmptySyncResult, En as requireEnvironmentWriteAuthorization, Et as writeJsonFile, F as calculatePullDiff, Fn as isLocalConfigured, Ft as navigationCommandItemToManagementInput, G as syncLocalMediaForPull, Gt as APPOINTMENT_SERVICE_VISIBILITY_VALUES, H as formatFieldPath, Hn as linkPayloadSchema, Ht as extractApiErrorMessage, I as buildJsonDiff, In as isRemoteConfigured, It as normalizeNavigationConfigItemForCommand, J as admitBinaryWriteDestination, Jt as ApiEnvelopeError, K as applyLocalMediaPush, Kt as ApiRequestError, L as hasPageOperations, Ln as loadSdkEnvironment, Lt as applyPushConfigPlan, M as hasPendingChanges, Mt as convertPulledFooterToLocal, N as findChangedFieldsWithValues, Nn as getEnvPrefix, Nt as convertPulledNavigationToLocal, O as calculateDiff, On as ErrorCodes, Ot as isMediaValue, P as formatHumanDiff, Pn as getEnvironmentDebugInfo, Pt as convertPulledPagesToLocal, Q as normalizeMediaIdentifierInput, Qt as mapEnvironmentExecutionOutcomesJson, R as pageMetadataForUpsert, Rn as createManagementClient, Rt as createPushConfigCommand, S as planCliCommandBatchForBindings, Sn as executeEnvironmentPlan, St as ensureDir, T as executeResidualSettingsSyncPlan, Tn as planEnvironmentWriteAuthorization, Tt as readJsonFile, U as revalidateLocalMediaPushPlan, Un as portablePageDesignSchema, Ut as normalizeApiError, V as formatFieldChange, Vn as sdkSettingsUpdateSchema, Vt as revalidatePushConfigPlan, Wn as sdkConfiguredBookingVerticalConfigSchema, Wt as isRecord$2, X as writeBinaryFileAtomic, Xt as deriveCmsApiUrlFromDashboardUrl, Y as readStableBinaryFile, Yt as unwrapResponse, Z as sha256, Zt as API_ENDPOINTS, _ as commandExecutionToReport, _n as runWithInvocation, _t as metadataFilePath, a as executeEntryCommandPlanAsReport, an as createOutputForCommand, at as readEntries, b as executeCompiledCliCommandPlanAsReport, bn as withErrorHandling, bt as writeMetadataFile, c as titleFromEntryData, cn as getOutputContext, ct as readEventsMeta, d as unsafeAsCliEntryIdentifier, dn as managementClientConfigFor, dt as readNavigationMeta, en as confirmAction, et as walkLocalContentMedia, f as unsafeAsCliFormSlug, fn as mapEntryForOutput, ft as readPagesMeta, g as commandCompileFailureToReport, gn as resolveCommandPath, gt as ensureMetadataDir, h as mutationCounterForEffect, hn as parsePaginationOptions, ht as writeMediaManifest, i as entrySiteCommandTypes, in as createListCommand, it as findLegacyEntryFiles, j as formatDiffSummary, jn as CliExit, jt as navigationIdentityMap, k as calculateFooterDiff, kn as formatError, kt as duplicateNavigationIdentityMessage, l as unsafeAsCliBlockIdentifier, ln as getOutputOnlyContext, lt as readFooterMeta, m as commandReportToSyncResult, mn as parseJsonData, mt as readVenuesMeta, n as entryCommandCompileErrorToReport, nn as createCommandContext, nt as downloadMedia, o as executeEntryCommandPlanAsSyncResult, on as currentInvocationEnvelope, ot as readAllMeta, p as unsafeAsCliPageIdentifier, pn as parseJsonArray, pt as readSettingsMeta, q as prepareLocalMediaForPush, qt as createBearerAPIClient, r as entryCommandReportToSyncResult, rn as createGetCommand, rt as extractMediaIdentifiers, s as syncResultForEntryCommandCompileError, sn as formatDateShort, st as readEventCategoriesMeta, t as compileEntryPushCommands, tn as createClientForEnv, tt as buildStorageUrl, u as unsafeAsCliContentTypeKey, un as handleCommandError, ut as readFormsMeta, v as commandReportHasFailures, vn as withCommandContext, vt as metadataTargetFromEnvironment, w as mergeManySyncResults, wn as planEnvironmentExecution, wt as listFiles, x as formatManagementError, xn as withOutputOnlyErrorHandling, xt as writeMetadataRecordMap, y as executeCliCommandPlan, yn as withConfirmation, yt as readMetadataFile, zn as ManagementApiError, zt as loadPushConfigTarget } from "../entryCommands-BGVgMNMw.mjs";
+import { r as CLI_VERSION, t as loadConfigFile } from "../load-config-BV9Ig2CH.mjs";
+import { a as RichTextDocSchema, c as isRecord$18, i as findUnfilledSentinels, n as buildEntryScaffold, o as isRichTextDoc, r as validateEntryInstance, s as isObjectRecord, t as eventUpsertInputSchema } from "../eventUpsertInputSchema-CdX--hHz.mjs";
+import { a as prepareScaffoldExecution, c as LOCAL_PACKAGE_VENDOR_DIR, d as loadGeneratedPackageRanges, i as preflightScaffoldTargets, n as createScaffoldCompletion, s as deriveScaffoldLocalManifest, t as deriveScaffoldPlan } from "../plan-CFMj_Hee.mjs";
 import { config } from "dotenv";
 import { Command, CommanderError } from "commander";
 import * as fs$2 from "fs/promises";
@@ -5996,12 +5996,13 @@ function isAllowedTransformId(id) {
 }
 
 //#endregion
-//#region ../blocks/src/system/layout/repeaterGrid.ts
+//#region ../blocks/src/system/layout/repeaterGridModel.ts
 const DEFAULT_REPEATER_GRID_SPAN_FIELD_ID = "gridSpan";
 const DEFAULT_REPEATER_GRID_ROW_FIELD_ID = "gridRow";
 const DEFAULT_REPEATER_GRID_COLUMN_FIELD_ID = "gridColumn";
 const MIN_COLUMNS = 1;
-const MAX_COLUMNS = 4;
+const MAX_REPEATER_GRID_COLUMNS = 6;
+const MAX_COLUMNS = MAX_REPEATER_GRID_COLUMNS;
 function normalizeInteger(value) {
 	if (typeof value === "number" && Number.isFinite(value)) {
 		return Math.trunc(value);
@@ -6073,7 +6074,7 @@ function createRepeaterGridSpanField(options) {
 	const fieldId = resolveRepeaterGridSpanFieldId(options);
 	const label = asNonEmptyString(options?.label) ?? "Grid span";
 	const description = asNonEmptyString(options?.description) ?? "Columns occupied by this item in layout-grid mode.";
-	const defaultSpan = normalizeRepeaterGridColumns(options?.defaultSpan ?? 1);
+	const defaultSpan = clamp(normalizeRepeaterGridColumns(options?.defaultSpan ?? 1), 1, 4);
 	return {
 		id: fieldId,
 		type: "select",
@@ -6136,16 +6137,10 @@ function withRepeaterGridSpanField(fields$1, options) {
 	return [createRepeaterGridSpanField(options), ...fields$1];
 }
 function withRepeaterGridPositionFields(fields$1, options) {
-	let nextFields = [...fields$1];
 	const rowFieldId = resolveRepeaterGridRowFieldId(options?.row);
-	if (!nextFields.some((field) => field.id === rowFieldId)) {
-		nextFields = [createRepeaterGridRowField(options?.row), ...nextFields];
-	}
+	const withRow = fields$1.some((field) => field.id === rowFieldId) ? [...fields$1] : [createRepeaterGridRowField(options?.row), ...fields$1];
 	const columnFieldId = resolveRepeaterGridColumnFieldId(options?.column);
-	if (!nextFields.some((field) => field.id === columnFieldId)) {
-		nextFields = [createRepeaterGridColumnField(options?.column), ...nextFields];
-	}
-	return nextFields;
+	return withRow.some((field) => field.id === columnFieldId) ? withRow : [createRepeaterGridColumnField(options?.column), ...withRow];
 }
 function withRepeaterGridSpanFieldOnItemTypes(itemTypes, options) {
 	const entries = Object.entries(itemTypes).map(([typeKey, itemType]) => {
@@ -6192,7 +6187,26 @@ function resolveRepeaterGridColumnsForBreakpoint(values, bindings, breakpoint) {
 	}
 	return MIN_COLUMNS;
 }
-function normalizeRepeaterGridSpan(value, activeColumns) {
+/** Strict admission; rendering normalization never grants permission to persist. */
+function parseRepeaterGridInteger(value) {
+	if (typeof value !== "number" && (typeof value !== "string" || !value.trim())) return null;
+	const number = Number(value);
+	return Number.isInteger(number) ? number : null;
+}
+function isAcceptedRepeaterGridSpan(value, columns, acceptedSpans$1) {
+	const span = parseRepeaterGridInteger(value);
+	return span != null && span >= 1 && span <= columns && (!acceptedSpans$1 || acceptedSpans$1.includes(span));
+}
+function resolveRepeaterGridAcceptedSpans(fields$1, spanField) {
+	const field = fields$1.find((candidate) => candidate.id === spanField);
+	return field?.type === "select" ? (field.options ?? []).map((option) => Number(option.value)) : undefined;
+}
+function normalizeRepeaterGridSpan(value, activeColumns, acceptedSpans$1) {
+	if (acceptedSpans$1) {
+		const valid = acceptedSpans$1.filter((span) => span <= activeColumns);
+		const parsed$1 = parseRepeaterGridInteger(value);
+		return parsed$1 != null && valid.includes(parsed$1) ? parsed$1 : valid.length ? Math.min(...valid) : 1;
+	}
 	const parsed = normalizeInteger(value);
 	if (parsed == null) {
 		return 1;
@@ -6237,12 +6251,14 @@ function getOverlappingItemIds(input) {
 	return new Set(buildPlacementCells(input).flatMap((col) => Array.from(input.occupancy.get(toRowCellKey(input.row, col, input.columns)) ?? []).filter((id) => !input.excludedIds?.has(id))));
 }
 function normalizeInputItem(item, columns, sourceIndex) {
-	const span = normalizeRepeaterGridSpan(item.span, columns);
+	const span = normalizeRepeaterGridSpan(item.span, columns, item.acceptedSpans);
 	const row$1 = normalizeRepeaterGridRow(item.row);
 	const colStart = normalizeRepeaterGridColStart(item.colStart, columns, span);
 	const colEnd = colStart + span - 1;
 	return {
 		id: item.id,
+		startNewRow: item.startNewRow,
+		acceptedSpans: item.acceptedSpans,
 		sourceIndex,
 		span,
 		row: row$1,
@@ -6251,8 +6267,134 @@ function normalizeInputItem(item, columns, sourceIndex) {
 		startCell: toRowCellKey(row$1, colStart, columns)
 	};
 }
+/** Ordered, non-dense placement. Rendering clamps widths; admission checks originals separately. */
+function flowRepeaterGridItems(items, columns) {
+	const count = normalizeRepeaterGridColumns(columns);
+	return items.reduce((placed, item) => {
+		const span = normalizeRepeaterGridSpan(item.span, count);
+		const previous = placed.at(-1);
+		const nextColumn = previous ? previous.colStart + previous.span : 1;
+		const wraps = previous != null && (item.startNewRow === true || nextColumn + span - 1 > count);
+		return [...placed, {
+			...item,
+			span,
+			row: (previous?.row ?? 1) + (wraps ? 1 : 0),
+			colStart: wraps ? 1 : nextColumn
+		}];
+	}, []);
+}
+/** @internal */
+function orderedGridItems(layout) {
+	return [...layout.placements].sort((a$1, b$1) => a$1.sourceIndex - b$1.sourceIndex);
+}
+function isRepeaterGridLayoutInvalid(layout) {
+	return layout.hasInvalidItems || layout.hasCollisions || layout.overCapacity;
+}
+function hasInvalidGridItems(items, columns, policy) {
+	const flow = policy === "flow" ? flowRepeaterGridItems(items, columns) : null;
+	return items.some((item, index) => !isValidGridItemGeometry(item, columns) || flow != null && (item.row !== flow[index]?.row || item.colStart !== flow[index]?.colStart));
+}
+function isValidGridItemGeometry(item, columns) {
+	return isAcceptedRepeaterGridSpan(item.span, columns, item.acceptedSpans) && parseRepeaterGridInteger(item.row) != null && item.row >= 1 && parseRepeaterGridInteger(item.colStart) != null && item.colStart >= 1 && item.colStart + item.span - 1 <= columns;
+}
+function findFlowAppendPlacement(layout, span, startNewRow) {
+	const next = flowRepeaterGridItems([...orderedGridItems(layout), {
+		id: "new",
+		span,
+		row: 1,
+		colStart: 1,
+		startNewRow
+	}], layout.columns).at(-1);
+	return !isRepeaterGridLayoutInvalid(layout) && next && (layout.maxRows == null || next.row <= layout.maxRows) ? {
+		row: next.row,
+		colStart: next.colStart
+	} : null;
+}
+/** @internal */
+function planFlowItems(layout, items) {
+	const placed = flowRepeaterGridItems(items, layout.columns);
+	if (isRepeaterGridLayoutInvalid(layout) || placed.some((item) => !isAcceptedRepeaterGridSpan(item.span, layout.columns, item.acceptedSpans) || layout.maxRows != null && item.row > layout.maxRows)) return { kind: "blocked" };
+	const [first, ...rest] = placed.map(({ id, row: row$1, colStart, span }) => ({
+		id,
+		row: row$1,
+		colStart,
+		span
+	}));
+	return first ? {
+		kind: "move",
+		updates: [first, ...rest]
+	} : { kind: "unchanged" };
+}
+/** Insertion reorder, with a complete coordinate write for the resulting order. */
+function planRepeaterGridReorder(layout, id, to, interaction = "step") {
+	if (layout.placementPolicy !== "flow") return { kind: "blocked" };
+	const items = orderedGridItems(layout);
+	const from = items.findIndex((item) => item.id === id);
+	if (from < 0 || to < 0 || to >= items.length) return { kind: "blocked" };
+	if (from === to) return { kind: "unchanged" };
+	const active = items[from];
+	if (!active) return { kind: "blocked" };
+	return decideFlowReorder({
+		layout,
+		items,
+		active,
+		from,
+		to,
+		interaction
+	});
+}
+function decideFlowReorder(input) {
+	const { layout, items, active, from, to, interaction } = input;
+	const id = active.id;
+	const remaining = items.filter((item) => item.id !== id);
+	const inserted = [
+		...remaining.slice(0, to),
+		active,
+		...remaining.slice(to)
+	];
+	const clearRowBreak = interaction === "drag" && active.startNewRow === true && dragInsertsWithinRow(items, from, to, layout.columns);
+	const nextItems = clearRowBreak ? inserted.map((item) => item.id === id ? {
+		...item,
+		startNewRow: false
+	} : item) : inserted;
+	const decision = planFlowItems(layout, nextItems);
+	return decision.kind === "move" ? {
+		...decision,
+		reorder: {
+			id,
+			from,
+			to
+		},
+		...clearRowBreak ? { startNewRowUpdate: {
+			id,
+			value: false
+		} } : {}
+	} : decision;
+}
+/** Read the insertion bar position, independently of the dragged width. */
+function dragInsertsWithinRow(items, from, to, columns) {
+	const target = items[to];
+	if (!target) return false;
+	const column = from < to ? target.colEnd + 1 : target.colStart;
+	return column > 1 && column <= columns;
+}
+function planRepeaterGridStartNewRow(layout, id, value) {
+	const active = layout.byId[id];
+	if (layout.placementPolicy !== "flow" || !active) return { kind: "blocked" };
+	const decision = planFlowItems(layout, orderedGridItems(layout).map((item) => item.id === id ? {
+		...item,
+		startNewRow: value
+	} : item));
+	return decision.kind === "move" ? {
+		...decision,
+		startNewRowUpdate: {
+			id,
+			value
+		}
+	} : decision;
+}
 function buildRepeaterGridLayout(input) {
-	const columns = clamp(Math.max(1, Math.trunc(input.columns)), MIN_COLUMNS, MAX_COLUMNS);
+	const columns = normalizeRepeaterGridColumns(input.columns);
 	const maxRows = input.maxRows != null ? Math.max(1, Math.trunc(input.maxRows)) : undefined;
 	const capacityCells = maxRows != null ? maxRows * columns : undefined;
 	const placements = input.items.map((item, sourceIndex) => normalizeInputItem(item, columns, sourceIndex)).sort((a$1, b$1) => {
@@ -6265,55 +6407,58 @@ function buildRepeaterGridLayout(input) {
 	const { hasCollisions } = buildOccupancyByCell(placements, columns);
 	const overCapacity = maxRows != null && maxRowUsed > maxRows;
 	return {
+		placementPolicy: input.placementPolicy,
+		sourceItems: input.items.map((item) => ({ ...item })),
 		columns,
 		maxRows,
 		capacityCells,
 		maxRowUsed,
 		overCapacity,
 		hasCollisions,
+		hasInvalidItems: hasInvalidGridItems(input.items, columns, input.placementPolicy),
 		placements,
 		byId
 	};
 }
 function findFirstAvailableRepeaterGridPlacement(input) {
-	const columns = clamp(Math.max(1, Math.trunc(input.columns)), MIN_COLUMNS, MAX_COLUMNS);
+	const columns = normalizeRepeaterGridColumns(input.columns);
 	const maxRows = input.maxRows != null ? Math.max(1, Math.trunc(input.maxRows)) : undefined;
-	const span = normalizeRepeaterGridSpan(input.newItemSpan, columns);
+	if (!isAcceptedRepeaterGridSpan(input.newItemSpan, columns, input.acceptedSpans)) return null;
+	const span = normalizeRepeaterGridSpan(input.newItemSpan, columns, input.acceptedSpans);
 	const layout = buildRepeaterGridLayout({
 		items: input.items,
 		columns,
-		maxRows
+		maxRows,
+		placementPolicy: input.placementPolicy
 	});
+	if (input.placementPolicy === "flow") return findFlowAppendPlacement(layout, span, input.startNewRow);
 	const { occupancy } = buildOccupancyByCell(layout.placements, columns);
 	const rowLimit = maxRows ?? Math.max(1, layout.maxRowUsed + 1);
-	for (let row$1 = 1; row$1 <= rowLimit; row$1 += 1) {
-		const maxColStart = Math.max(1, columns - span + 1);
-		for (let colStart = 1; colStart <= maxColStart; colStart += 1) {
-			const overlaps = getOverlappingItemIds({
-				occupancy,
-				row: row$1,
-				colStart,
-				span,
-				columns
-			});
-			if (overlaps.size === 0) {
-				return {
-					row: row$1,
-					colStart
-				};
-			}
-		}
-	}
-	return null;
+	if (isRepeaterGridLayoutInvalid(layout)) return null;
+	const maxColStart = columns - span + 1;
+	return Array.from({ length: rowLimit * maxColStart }, (_$1, index) => ({
+		row: Math.floor(index / maxColStart) + 1,
+		colStart: index % maxColStart + 1
+	})).find(({ row: row$1, colStart }) => getOverlappingItemIds({
+		occupancy,
+		row: row$1,
+		colStart,
+		span,
+		columns
+	}).size === 0) ?? null;
 }
 function canAppendRepeaterGridItem(input) {
 	return findFirstAvailableRepeaterGridPlacement({
 		items: input.items,
 		newItemSpan: input.newItemSpan,
+		acceptedSpans: input.acceptedSpans,
 		columns: input.columns,
 		maxRows: input.maxRows
 	}) != null;
 }
+
+//#endregion
+//#region ../blocks/src/system/layout/repeaterGrid.ts
 function placementsOverlap(left, right) {
 	return left.row === right.row && left.colStart < right.colStart + right.span && right.colStart < left.colStart + left.span;
 }
@@ -6333,10 +6478,44 @@ function swapPositionUpdates(active, target) {
 		span: target.span
 	}];
 }
+/** Admission retains raw authoring geometry; display-only callers may supply placements alone. */
+function sourceGridItems(layout) {
+	return layout.sourceItems ?? layout.placements;
+}
+/** Repair edits may remove existing defects, but cannot introduce another one. */
+function gridDefects(layout) {
+	const geometry = sourceGridItems(layout).flatMap((item) => [
+		...!isAcceptedRepeaterGridSpan(item.span, layout.columns, item.acceptedSpans) ? [`span:${item.id}`] : [],
+		...!Number.isInteger(item.row) || item.row < 1 ? [`row:${item.id}`] : [],
+		...!Number.isInteger(item.colStart) || item.colStart < 1 || item.colStart + item.span - 1 > layout.columns ? [`column:${item.id}`] : []
+	]);
+	const collisions = layout.placements.flatMap((item, index) => layout.placements.slice(index + 1).filter((other) => placementsOverlap(item, other)).map((other) => `collision:${[item.id, other.id].sort().join(":")}`));
+	const capacity = layout.placements.filter((item) => layout.maxRows != null && item.row > layout.maxRows).map((item) => `capacity:${item.id}`);
+	return new Set([
+		...geometry,
+		...collisions,
+		...capacity,
+		...(layout.invalidCoordinateIds ?? []).map((id) => `coordinate:${id}`)
+	]);
+}
 function validateGridMove(layout, updates) {
-	const moved = updates;
-	const stationary = layout.placements.filter((placement) => !updates.some((update) => update.id === placement.id));
-	const valid = moved.every((placement, index) => placement.colStart >= 1 && placement.colStart + placement.span - 1 <= layout.columns && placement.row >= 1 && (layout.maxRows == null || placement.row <= layout.maxRows) && !stationary.some((other) => placementsOverlap(placement, other)) && !moved.slice(index + 1).some((other) => placementsOverlap(placement, other)));
+	const items = sourceGridItems(layout).map((item) => ({
+		...item,
+		...updates.find((update) => update.id === item.id)
+	}));
+	const candidate = buildRepeaterGridLayout({
+		items,
+		columns: layout.columns,
+		maxRows: layout.maxRows,
+		placementPolicy: layout.placementPolicy
+	});
+	const unresolved = (layout.invalidCoordinateIds ?? []).filter((id) => !updates.some((update) => update.id === id));
+	const before = gridDefects(layout);
+	const after = gridDefects({
+		...candidate,
+		invalidCoordinateIds: unresolved
+	});
+	const valid = before.size === 0 ? after.size === 0 : after.size < before.size && [...after].every((defect) => before.has(defect));
 	return valid ? {
 		kind: "move",
 		updates
@@ -6347,7 +6526,7 @@ function decideGridDrop(layout, active, destination) {
 	if (occupants.length > 1) return { kind: "blocked" };
 	const target = occupants[0];
 	if (target) return validateGridMove(layout, swapPositionUpdates(active, target));
-	if (destination.row === active.row && destination.colStart === active.colStart) return { kind: "unchanged" };
+	if (destination.row === active.row && destination.colStart === active.colStart && !isRepeaterGridLayoutInvalid(layout)) return { kind: "unchanged" };
 	return validateGridMove(layout, [{
 		id: active.id,
 		row: destination.row,
@@ -6358,9 +6537,16 @@ function decideGridDrop(layout, active, destination) {
 function buildRepeaterGridDropTargets(input) {
 	const { layout, draggedId, rowsToRender } = input;
 	const active = layout.byId[draggedId];
-	if (!active) return [];
+	if (!active || layout.placementPolicy === "flow" && isRepeaterGridLayoutInvalid(layout)) return [];
+	if (layout.placementPolicy === "flow") return orderedGridItems(layout).map((item, index) => ({
+		id: `repeater-grid-drop-${item.row}-${item.colStart}`,
+		row: item.row,
+		colStart: item.colStart,
+		cell: item.startCell,
+		decision: planRepeaterGridReorder(layout, draggedId, index, input.interaction ?? "drag")
+	}));
 	const rowCeiling = layout.maxRows ?? Math.max(1, rowsToRender ?? layout.maxRowUsed + 1, active.row + 1);
-	return Array.from({ length: rowCeiling * layout.columns }, (_$1, index) => {
+	const targets = Array.from({ length: rowCeiling * layout.columns }, (_$1, index) => {
 		const row$1 = Math.floor(index / layout.columns) + 1;
 		const colStart = index % layout.columns + 1;
 		return {
@@ -6374,6 +6560,205 @@ function buildRepeaterGridDropTargets(input) {
 			})
 		};
 	});
+	return targets.some((target) => target.row === active.row && target.colStart === active.colStart) ? targets : [...targets, {
+		id: `repeater-grid-drop-${active.row}-${active.colStart}`,
+		row: active.row,
+		colStart: active.colStart,
+		cell: active.startCell,
+		decision: { kind: "unchanged" }
+	}];
+}
+/** Width edits keep the item's start when it fits; otherwise relocate it to the first free cell.
+* Neighbours keep their positions. A full bounded grid blocks the change without partial writes.
+*/
+function planRepeaterGridSpanChange(input) {
+	const { layout, id, span } = input;
+	const active = layout.byId[id];
+	if (layout.placementPolicy === "flow" && isRepeaterGridLayoutInvalid(layout)) return { kind: "blocked" };
+	if (!active || !isAcceptedRepeaterGridSpan(span, layout.columns, active.acceptedSpans)) return { kind: "blocked" };
+	const nextSpan = Number(span);
+	if (!isRepeaterGridLayoutInvalid(layout) && sourceGridItems(layout).find((item) => item.id === id)?.span === nextSpan) return { kind: "unchanged" };
+	if (layout.placementPolicy === "flow") return planFlowItems(layout, orderedGridItems(layout).map((item) => item.id === id ? {
+		...item,
+		span: nextSpan
+	} : item));
+	return planFreeGridSpanChange(layout, active, nextSpan);
+}
+/** Free width edits retain the current start when possible, then use the shared first-free planner. */
+function planFreeGridSpanChange(layout, active, nextSpan) {
+	const id = active.id;
+	const atCurrent = validateGridMove(layout, [{
+		id,
+		span: nextSpan,
+		row: active.row,
+		colStart: active.colStart
+	}]);
+	if (atCurrent.kind === "move") return atCurrent;
+	const destination = findFirstAvailableRepeaterGridPlacement({
+		items: layout.placements.filter((item) => item.id !== id),
+		newItemSpan: nextSpan,
+		acceptedSpans: active.acceptedSpans,
+		columns: layout.columns,
+		maxRows: layout.maxRows
+	});
+	return destination ? validateGridMove(layout, [{
+		id,
+		span: nextSpan,
+		...destination
+	}]) : { kind: "blocked" };
+}
+/** Narrow rendering is a projection only. Never feed these placements into an authoring write. */
+function projectRepeaterGridLayout(layout, columns) {
+	if (isRepeaterGridLayoutInvalid(layout)) return projectRepeaterGridLayoutForRendering(layout, columns);
+	if (columns === layout.columns) return layout;
+	if (layout.placementPolicy === "flow") return buildProjectedRepeaterGridLayout(layout, flowRepeaterGridItems(orderedGridItems(layout), columns), columns);
+	const items = layout.placements.reduce((placed, item) => {
+		const span = normalizeRepeaterGridSpan(item.span, columns);
+		const destination = findFirstAvailableRepeaterGridPlacement({
+			items: placed,
+			newItemSpan: span,
+			columns
+		});
+		return [...placed, {
+			id: item.id,
+			span,
+			row: destination?.row ?? placed.length + 1,
+			colStart: destination?.colStart ?? 1
+		}];
+	}, []);
+	return buildProjectedRepeaterGridLayout(layout, items, columns);
+}
+function buildProjectedRepeaterGridLayout(source, items, columns) {
+	const projected = buildRepeaterGridLayout({
+		items: items.map(({ id, span, row: row$1, colStart, startNewRow }) => ({
+			id,
+			span,
+			row: row$1,
+			colStart,
+			startNewRow
+		})),
+		columns,
+		placementPolicy: source.placementPolicy === "flow" || isRepeaterGridLayoutInvalid(source) ? "flow" : source.placementPolicy
+	});
+	const placements = projected.placements.map((item) => ({
+		...item,
+		sourceIndex: source.byId[item.id]?.sourceIndex ?? item.sourceIndex
+	}));
+	return {
+		...projected,
+		placements,
+		byId: Object.fromEntries(placements.map((item) => [item.id, item]))
+	};
+}
+/** Public fallback: preserve saved array order, use non-dense auto-placement, and ignore authoring capacity. */
+function projectRepeaterGridLayoutForRendering(layout, columns = layout.columns) {
+	if (!isRepeaterGridLayoutInvalid(layout)) {
+		return projectRepeaterGridLayout(layout, columns);
+	}
+	const count = normalizeRepeaterGridColumns(columns);
+	return buildProjectedRepeaterGridLayout(layout, flowRepeaterGridItems(orderedGridItems(layout), count), count);
+}
+/** An explicit column reduction re-places free grids through the existing placement primitive. */
+function planRepeaterGridColumnChange(layout, columns) {
+	if (layout.placementPolicy === "flow" || columns >= layout.columns) return { kind: "unchanged" };
+	if (isRepeaterGridLayoutInvalid(layout)) return { kind: "blocked" };
+	const placed = orderedGridItems(layout).reduce((items, item) => {
+		if (!items) return null;
+		const bounded = normalizeRepeaterGridSpan(item.span, columns);
+		const span = item.acceptedSpans ? Math.max(0, ...item.acceptedSpans.filter((width) => width <= bounded)) : bounded;
+		const destination = findFirstAvailableRepeaterGridPlacement({
+			items,
+			columns,
+			maxRows: layout.maxRows,
+			newItemSpan: span,
+			acceptedSpans: item.acceptedSpans
+		});
+		return destination ? [...items, {
+			...item,
+			span,
+			...destination
+		}] : null;
+	}, []);
+	const [first, ...rest] = placed ?? [];
+	return first ? {
+		kind: "move",
+		updates: [first, ...rest]
+	} : placed ? { kind: "unchanged" } : { kind: "blocked" };
+}
+
+//#endregion
+//#region ../blocks/src/system/manifest/layoutGridConfiguration.ts
+const itemFieldsSchema = z.object({ fields: z.array(z.object({
+	id: z.string(),
+	type: z.string(),
+	defaultValue: z.unknown().optional(),
+	options: z.array(z.object({ value: z.string() })).optional(),
+	multiple: z.boolean().optional(),
+	source: z.object({ kind: z.string() }).optional()
+})) });
+function validateSpanSelect(span, columns, ctx) {
+	if (span.type !== "select") return;
+	const options = span.options ?? [];
+	const invalidOptions = options.some((option) => !isAcceptedRepeaterGridSpan(option.value, columns) || String(Number(option.value)) !== option.value);
+	if (span.multiple || options.length === 0 || invalidOptions || span.source && span.source.kind !== "static") {
+		ctx.addIssue({
+			code: "custom",
+			path: ["ui", "layoutGridSpanField"],
+			message: `Layout-grid span select must have single, static integer options within 1..${columns}`
+		});
+	}
+	if (span.defaultValue !== undefined && !options.some((option) => option.value === span.defaultValue)) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["ui", "layoutGridSpanField"],
+			message: "Layout-grid default span must be one of the span select options"
+		});
+	}
+}
+/** Both monomorphic and polymorphic item schemas have the same layout contract. */
+function validateLayoutGridConfiguration(data, ctx) {
+	const ui = data.ui;
+	if (ui?.repeaterPreset !== "layoutGrid") return;
+	if (ui.layoutGridColumns !== undefined === (ui.layoutGridColumnsFields !== undefined)) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["ui", "layoutGridColumns"],
+			message: "Layout-grid requires exactly one of ui.layoutGridColumns or ui.layoutGridColumnsFields.lg; do not set both"
+		});
+	}
+	const spanId = resolveRepeaterGridSpanFieldId({ id: ui.layoutGridSpanField });
+	const requiredIds = [
+		spanId,
+		resolveRepeaterGridRowFieldId({ id: ui.layoutGridRowField }),
+		resolveRepeaterGridColumnFieldId({ id: ui.layoutGridColumnField })
+	];
+	const schemas = data.polymorphic && data.itemTypes ? Object.values(data.itemTypes) : [data.schema];
+	schemas.forEach((schema) => {
+		const parsed = itemFieldsSchema.safeParse(schema);
+		if (!parsed.success) return;
+		if (!requiredIds.every((id) => parsed.data.fields.some((field) => field.id === id))) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["ui", "layoutGridRowField"],
+				message: `layoutGrid repeaters require span/row/column fields (${requiredIds.join(", ")}) to exist in repeater item fields`
+			});
+		}
+		if (ui.layoutGridStartNewRowField && !parsed.data.fields.some((field) => field.id === ui.layoutGridStartNewRowField && field.type === "boolean")) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["ui", "layoutGridStartNewRowField"],
+				message: "Layout-grid Start a new row field must reference a boolean item field"
+			});
+		}
+		if (ui.layoutGridStartNewRowField && ui.layoutGridColumns === undefined) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["ui", "layoutGridStartNewRowField"],
+				message: "Layout-grid Start a new row requires fixed columns (flow placement)"
+			});
+		}
+		parsed.data.fields.filter((field) => field.id === spanId).forEach((span) => validateSpanSelect(span, ui.layoutGridColumns ?? MAX_REPEATER_GRID_COLUMNS, ctx));
+	});
 }
 
 //#endregion
@@ -6560,6 +6945,14 @@ const uiSchema = z.object({
 	thumbnailLabelField: z.string().optional(),
 	thumbnailAspectRatio: z.string().optional(),
 	thumbnailCardDensity: z.enum(["compact", "comfortable"]).optional(),
+	layoutGridColumns: z.union([
+		z.literal(1),
+		z.literal(2),
+		z.literal(3),
+		z.literal(4),
+		z.literal(5),
+		z.literal(6)
+	]).optional(),
 	layoutGridColumnsFields: z.object({
 		base: z.string().optional(),
 		sm: z.string().optional(),
@@ -6568,6 +6961,7 @@ const uiSchema = z.object({
 		xl: z.string().optional()
 	}).optional(),
 	layoutGridSpanField: z.string().optional(),
+	layoutGridStartNewRowField: z.string().optional(),
 	layoutGridRowField: z.string().optional(),
 	layoutGridColumnField: z.string().optional(),
 	layoutGridMaxRows: z.number().int().positive().optional(),
@@ -6589,7 +6983,26 @@ const uiSchema = z.object({
 		"style"
 	]).optional(),
 	valueContract: z.enum(["boxBackground"]).optional()
-}).partial();
+}).partial().superRefine((ui, ctx) => {
+	if (ui.layoutGridColumns !== undefined && ui.layoutGridColumnsFields !== undefined) {
+		ctx.addIssue({
+			code: "custom",
+			path: ["layoutGridColumns"],
+			message: "Layout-grid requires exactly one of ui.layoutGridColumns or ui.layoutGridColumnsFields.lg; do not set both"
+		});
+	}
+}).transform((input) => {
+	const { layoutGridColumns, layoutGridColumnsFields, ...ui } = input;
+	if (layoutGridColumns !== undefined) return {
+		...ui,
+		layoutGridColumns
+	};
+	if (layoutGridColumnsFields !== undefined) return {
+		...ui,
+		layoutGridColumnsFields
+	};
+	return ui;
+});
 const baseFieldSchema = z.object({
 	id: z.string().min(1, "Field id is required"),
 	label: z.string().min(1, "Field label is required"),
@@ -6775,44 +7188,7 @@ const repeaterFieldSchema = baseFieldSchema.extend({
 	const hasSchema = data.schema !== undefined;
 	const hasPolymorphic = data.polymorphic === true && data.itemTypes !== undefined;
 	return hasSchema !== hasPolymorphic;
-}, { message: "Repeater must have either 'schema' (monomorphic) or 'polymorphic: true' with 'itemTypes' (polymorphic)" }).refine((data) => {
-	if (data.ui?.repeaterPreset !== "layoutGrid") {
-		return true;
-	}
-	const columnsFields = data.ui.layoutGridColumnsFields;
-	return !!columnsFields?.lg;
-}, {
-	message: "ui.layoutGridColumnsFields.lg is required when ui.repeaterPreset is 'layoutGrid'",
-	path: [
-		"ui",
-		"layoutGridColumnsFields",
-		"lg"
-	]
-}).refine((data) => {
-	if (data.ui?.repeaterPreset !== "layoutGrid") {
-		return true;
-	}
-	const spanField = resolveRepeaterGridSpanFieldId({ id: typeof data.ui.layoutGridSpanField === "string" ? data.ui.layoutGridSpanField : undefined });
-	const rowField = resolveRepeaterGridRowFieldId({ id: typeof data.ui.layoutGridRowField === "string" ? data.ui.layoutGridRowField : undefined });
-	const columnField = resolveRepeaterGridColumnFieldId({ id: typeof data.ui.layoutGridColumnField === "string" ? data.ui.layoutGridColumnField : undefined });
-	const requiredFieldIds = [
-		spanField,
-		rowField,
-		columnField
-	];
-	if (data.polymorphic && data.itemTypes) {
-		const itemTypes = Object.values(data.itemTypes);
-		return itemTypes.every((itemType) => Array.isArray(itemType.fields) && requiredFieldIds.every((requiredId) => itemType.fields?.some((field) => field.id === requiredId)));
-	}
-	const schemaFields = data.schema?.fields;
-	if (!schemaFields) {
-		return true;
-	}
-	return requiredFieldIds.every((requiredId) => schemaFields.some((field) => field.id === requiredId));
-}, {
-	message: `layoutGrid repeaters require span/row/column fields (defaults: '${DEFAULT_REPEATER_GRID_SPAN_FIELD_ID}', '${DEFAULT_REPEATER_GRID_ROW_FIELD_ID}', '${DEFAULT_REPEATER_GRID_COLUMN_FIELD_ID}') to exist in repeater item fields`,
-	path: ["ui", "layoutGridRowField"]
-}).refine((data) => {
+}, { message: "Repeater must have either 'schema' (monomorphic) or 'polymorphic: true' with 'itemTypes' (polymorphic)" }).superRefine(validateLayoutGridConfiguration).refine((data) => {
 	const thumbnailAspectRatio = data.ui?.thumbnailAspectRatio;
 	if (!thumbnailAspectRatio) {
 		return true;
@@ -7144,6 +7520,195 @@ const manifestSchema = z.object({
 	icon: z.string().optional()
 });
 
+//#endregion
+//#region ../blocks/src/lib/media.ts
+const MEDIA_TYPE_DISCRIMINANTS = mediaTypeDiscriminants;
+const PUBLIC_DOWNLOAD_MEDIA_TYPES = [
+	"document",
+	"spreadsheet",
+	"archive",
+	"audio"
+];
+function isMediaTypeDiscriminant(value) {
+	return typeof value === "string" && MEDIA_TYPE_DISCRIMINANTS.includes(value);
+}
+function mediaTypeDiscriminantFromMimeType(mimeType) {
+	const classified = classifyKnownMimeType(mimeType);
+	if (!classified.ok) return null;
+	switch (classified.value.tag) {
+		case "image":
+		case "video":
+		case "audio":
+		case "document":
+		case "spreadsheet":
+		case "archive": return classified.value.tag;
+		case "font": return null;
+	}
+}
+
+//#endregion
+//#region ../blocks/src/system/manifest/fieldValidation/writeCanonicalization.ts
+function allGroupChildPlans(plan) {
+	return plan.childSelection.kind === "all" ? plan.childSelection.fields : plan.childSelection.tabs.flatMap((tab) => tab.fields);
+}
+function selectedGroupChildPlans(plan, value) {
+	if (plan.childSelection.kind === "all") return plan.childSelection.fields;
+	if (!isPlainObject$7(value)) return [];
+	const selectedType = value[plan.childSelection.activeTabField];
+	return plan.childSelection.tabs.find((tab) => tab.typeId === selectedType)?.fields ?? [];
+}
+function canonicalizeObjectForWrite(plans, value) {
+	if (!isPlainObject$7(value)) return value;
+	const canonical$1 = { ...value };
+	for (const plan of plans) {
+		if (!(plan.fieldId in canonical$1)) continue;
+		canonical$1[plan.fieldId] = canonicalizeFieldValue(plan, canonical$1[plan.fieldId]);
+	}
+	return omitUndefined(canonical$1);
+}
+function canonicalizeFieldValue(plan, value) {
+	switch (plan.kind) {
+		case "media": return canonicalizeMedia(value);
+		case "group": return plan.childSelection.kind === "discriminatedTabs" ? canonicalizeDiscriminatedGroup(plan, value) : canonicalizeObjectForWrite(plan.childSelection.fields, value);
+		case "repeater": return canonicalizeRepeater(plan, value);
+		case "string":
+		case "number":
+		case "boolean":
+		case "richText":
+		case "inlineText":
+		case "link":
+		case "select":
+		case "passthrough": return value;
+	}
+}
+function canonicalizeMedia(value) {
+	if (!isPlainObject$7(value)) return value;
+	const canonical$1 = { ...value };
+	if (mediaIdentifierSchema.safeParse(canonical$1.identifier).success) {
+		deleteEnvSpecificKeys(canonical$1);
+	}
+	return canonical$1;
+}
+function canonicalizeRepeater(plan, value) {
+	if (!isUnknownArray$3(value)) return value;
+	return value.map((item) => {
+		if (!isPlainObject$7(item)) return item;
+		const childPlans = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === item._type)?.fields : plan.repeatedItemPlan;
+		return childPlans ? canonicalizeObjectForWrite(childPlans, item) : item;
+	});
+}
+function canonicalizeDiscriminatedGroup(plan, value) {
+	if (!isPlainObject$7(value) || plan.childSelection.kind !== "discriminatedTabs") {
+		return value;
+	}
+	const selection = plan.childSelection;
+	const selectedPlans = selectedGroupChildPlans(plan, value);
+	const selectedIds = rootFieldIds(selectedPlans);
+	const allChildIds = rootFieldIds(allGroupChildPlans(plan));
+	const projected = Object.fromEntries(Object.entries(value).filter(([key]) => key === selection.activeTabField || selectedIds.has(key) || !allChildIds.has(key)));
+	const canonical$1 = omitUndefined(canonicalizeObjectForWrite(selectedPlans, projected));
+	if (plan.valueContract !== "boxBackground") return canonical$1;
+	const parsed = boxBackgroundSchema.safeParse(canonical$1);
+	return parsed.success ? parsed.data : canonical$1;
+}
+function rootFieldIds(plans) {
+	return new Set(plans.map((child) => child.fieldId.split(".")[0] ?? child.fieldId));
+}
+function omitUndefined(value) {
+	if (isUnknownArray$3(value)) return value.map(omitUndefined);
+	if (!isPlainObject$7(value)) return value;
+	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined).map(([key, field]) => [key, omitUndefined(field)]));
+}
+function isPlainObject$7(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnknownArray$3(value) {
+	return Array.isArray(value);
+}
+
+//#endregion
+//#region ../blocks/src/system/manifest/fieldValidation/layoutGrid.ts
+function layoutGridRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function resolveLayoutGridItemPlans(plan, item) {
+	return plan.repeatedItemVariants?.find((variant) => variant.typeId === item._type)?.fields ?? plan.repeatedItemPlan ?? [];
+}
+function layoutGridCoordinateFieldIds(plan) {
+	const grid$5 = plan.layoutGrid;
+	return grid$5 ? [
+		grid$5.spanField,
+		grid$5.rowField,
+		grid$5.columnField
+	] : [];
+}
+function acceptedSpans(plans, spanField) {
+	const span = plans.find((field) => field.fieldId === spanField);
+	if (span?.kind !== "select") return undefined;
+	const constraint = span.constraints.find((entry) => entry.kind === "selectOption");
+	return constraint?.kind === "selectOption" && constraint.source.kind === "static" ? constraint.source.values.map(Number) : [];
+}
+function gridIssue(plan, path$3, message) {
+	return {
+		kind: "invalidLayoutGrid",
+		fieldId: plan.fieldId,
+		label: plan.label,
+		path: path$3,
+		message
+	};
+}
+function buildLayoutGridForPlan(plan, value, values, ids) {
+	const grid$5 = plan.layoutGrid;
+	if (!grid$5) return null;
+	const columns = grid$5.columns ?? (grid$5.columnsFields ? resolveRepeaterGridColumnsForBreakpoint(values, grid$5.columnsFields, "lg") : 1);
+	const items = value.flatMap((item, index) => {
+		const row$1 = layoutGridRecord(item);
+		return row$1 ? [{
+			id: ids?.[index] ?? String(index),
+			startNewRow: grid$5.startNewRowField ? row$1[grid$5.startNewRowField] === true : false,
+			span: parseRepeaterGridInteger(row$1[grid$5.spanField]) ?? NaN,
+			row: parseRepeaterGridInteger(row$1[grid$5.rowField]) ?? NaN,
+			colStart: parseRepeaterGridInteger(row$1[grid$5.columnField]) ?? NaN,
+			acceptedSpans: acceptedSpans(resolveLayoutGridItemPlans(plan, row$1), grid$5.spanField)
+		}] : [];
+	});
+	return buildRepeaterGridLayout({
+		items,
+		columns,
+		maxRows: grid$5.maxRows,
+		placementPolicy: grid$5.columns === undefined ? "free" : "flow"
+	});
+}
+function validateGrid(plan, value, values, path$3) {
+	const layout = buildLayoutGridForPlan(plan, value, values);
+	if (!layout) return [];
+	if (layout.hasCollisions || layout.overCapacity) return [gridIssue(plan, path$3, "Some items overlap or do not fit in this layout. Adjust their widths or positions before saving.")];
+	return layout.hasInvalidItems ? [gridIssue(plan, path$3, "Choose an available width and a valid position for each item before saving.")] : [];
+}
+/** Root values resolve the same column bindings as the editor; recurse without changing any content. */
+function validateLayoutGridPlans(plans, value, rootValues = layoutGridRecord(value) ?? {}, parent = []) {
+	const values = layoutGridRecord(value);
+	if (!values) return [];
+	return plans.flatMap((plan) => {
+		const fieldValue = values[plan.fieldId];
+		const path$3 = [...parent, plan.fieldId];
+		if (plan.kind === "group") return validateLayoutGridPlans(allGroupChildPlans(plan), fieldValue, rootValues, path$3);
+		if (plan.kind !== "repeater" || !Array.isArray(fieldValue)) return [];
+		return [...validateGrid(plan, fieldValue, rootValues, path$3), ...fieldValue.flatMap((item, index) => {
+			const row$1 = layoutGridRecord(item);
+			return row$1 ? validateLayoutGridPlans(resolveLayoutGridItemPlans(plan, row$1), row$1, rootValues, [...path$3, index]) : [];
+		})];
+	});
+}
+/** User-authored column edits only; never run this as a load/render projection. */
+function planLayoutGridColumnEdit(plan, items, before, after) {
+	const grid$5 = plan.layoutGrid;
+	if (!grid$5?.columnsFields) return { kind: "unchanged" };
+	const columns = resolveRepeaterGridColumnsForBreakpoint(after, grid$5.columnsFields, "lg");
+	const previous = buildLayoutGridForPlan(plan, items, before);
+	return previous ? planRepeaterGridColumnChange(previous, columns) : { kind: "unchanged" };
+}
+
 //#endregion
 //#region ../blocks/src/system/inlineText.ts
 const inlineTextAccentTones = [
@@ -8602,112 +9167,6 @@ function isGeneratedBlockIconStale(value, currentStyleGuideVersionId) {
 	return getGeneratedBlockIconStyleState(value, currentStyleGuideVersionId).kind === "stale";
 }
 
-//#endregion
-//#region ../blocks/src/lib/media.ts
-const MEDIA_TYPE_DISCRIMINANTS = mediaTypeDiscriminants;
-const PUBLIC_DOWNLOAD_MEDIA_TYPES = [
-	"document",
-	"spreadsheet",
-	"archive",
-	"audio"
-];
-function isMediaTypeDiscriminant(value) {
-	return typeof value === "string" && MEDIA_TYPE_DISCRIMINANTS.includes(value);
-}
-function mediaTypeDiscriminantFromMimeType(mimeType) {
-	const classified = classifyKnownMimeType(mimeType);
-	if (!classified.ok) return null;
-	switch (classified.value.tag) {
-		case "image":
-		case "video":
-		case "audio":
-		case "document":
-		case "spreadsheet":
-		case "archive": return classified.value.tag;
-		case "font": return null;
-	}
-}
-
-//#endregion
-//#region ../blocks/src/system/manifest/fieldValidation/writeCanonicalization.ts
-function allGroupChildPlans(plan) {
-	return plan.childSelection.kind === "all" ? plan.childSelection.fields : plan.childSelection.tabs.flatMap((tab) => tab.fields);
-}
-function selectedGroupChildPlans(plan, value) {
-	if (plan.childSelection.kind === "all") return plan.childSelection.fields;
-	if (!isPlainObject$7(value)) return [];
-	const selectedType = value[plan.childSelection.activeTabField];
-	return plan.childSelection.tabs.find((tab) => tab.typeId === selectedType)?.fields ?? [];
-}
-function canonicalizeObjectForWrite(plans, value) {
-	if (!isPlainObject$7(value)) return value;
-	const canonical$1 = { ...value };
-	for (const plan of plans) {
-		if (!(plan.fieldId in canonical$1)) continue;
-		canonical$1[plan.fieldId] = canonicalizeFieldValue(plan, canonical$1[plan.fieldId]);
-	}
-	return omitUndefined(canonical$1);
-}
-function canonicalizeFieldValue(plan, value) {
-	switch (plan.kind) {
-		case "media": return canonicalizeMedia(value);
-		case "group": return plan.childSelection.kind === "discriminatedTabs" ? canonicalizeDiscriminatedGroup(plan, value) : canonicalizeObjectForWrite(plan.childSelection.fields, value);
-		case "repeater": return canonicalizeRepeater(plan, value);
-		case "string":
-		case "number":
-		case "boolean":
-		case "richText":
-		case "inlineText":
-		case "link":
-		case "select":
-		case "passthrough": return value;
-	}
-}
-function canonicalizeMedia(value) {
-	if (!isPlainObject$7(value)) return value;
-	const canonical$1 = { ...value };
-	if (mediaIdentifierSchema.safeParse(canonical$1.identifier).success) {
-		deleteEnvSpecificKeys(canonical$1);
-	}
-	return canonical$1;
-}
-function canonicalizeRepeater(plan, value) {
-	if (!isUnknownArray$3(value)) return value;
-	return value.map((item) => {
-		if (!isPlainObject$7(item)) return item;
-		const childPlans = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === item._type)?.fields : plan.repeatedItemPlan;
-		return childPlans ? canonicalizeObjectForWrite(childPlans, item) : item;
-	});
-}
-function canonicalizeDiscriminatedGroup(plan, value) {
-	if (!isPlainObject$7(value) || plan.childSelection.kind !== "discriminatedTabs") {
-		return value;
-	}
-	const selection = plan.childSelection;
-	const selectedPlans = selectedGroupChildPlans(plan, value);
-	const selectedIds = rootFieldIds(selectedPlans);
-	const allChildIds = rootFieldIds(allGroupChildPlans(plan));
-	const projected = Object.fromEntries(Object.entries(value).filter(([key]) => key === selection.activeTabField || selectedIds.has(key) || !allChildIds.has(key)));
-	const canonical$1 = omitUndefined(canonicalizeObjectForWrite(selectedPlans, projected));
-	if (plan.valueContract !== "boxBackground") return canonical$1;
-	const parsed = boxBackgroundSchema.safeParse(canonical$1);
-	return parsed.success ? parsed.data : canonical$1;
-}
-function rootFieldIds(plans) {
-	return new Set(plans.map((child) => child.fieldId.split(".")[0] ?? child.fieldId));
-}
-function omitUndefined(value) {
-	if (isUnknownArray$3(value)) return value.map(omitUndefined);
-	if (!isPlainObject$7(value)) return value;
-	return Object.fromEntries(Object.entries(value).filter(([, field]) => field !== undefined).map(([key, field]) => [key, omitUndefined(field)]));
-}
-function isPlainObject$7(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isUnknownArray$3(value) {
-	return Array.isArray(value);
-}
-
 //#endregion
 //#region ../blocks/src/system/fields/backgroundContentAudit.ts
 const BACKGROUND_SLOTS = [
@@ -8773,7 +9232,7 @@ function validationContext(options = {}) {
 	const isDraft = options.mode === "draft";
 	return {
 		allowNull: options.allowNull ?? true,
-		allowIncomplete: isDraft || (options.allowIncomplete ?? false),
+		allowIncomplete: options.mode === "storable" ? false : isDraft || (options.allowIncomplete ?? false),
 		mode: options.mode ?? "strict"
 	};
 }
@@ -8797,18 +9256,20 @@ function parseFieldPathKey(key) {
 		return Number.isInteger(numeric) && String(numeric) === segment ? numeric : segment;
 	});
 }
+const simpleIssueMessages = {
+	required: "This field is required",
+	invalidEmail: "Enter a valid email address",
+	invalidPhone: "Enter a valid phone number",
+	invalidPattern: "Check the format and try again",
+	invalidUrl: "Enter a valid web address",
+	invalidDate: "Choose a valid date",
+	invalidTime: "Choose a valid time",
+	invalidDateTime: "Choose a valid date and time"
+};
 function fieldIssueToMessage(issue$1) {
 	switch (issue$1.kind) {
-		case "required": return "This field is required";
 		case "wrongType": return `${issue$1.label} needs ${issue$1.expected}`;
 		case "tooLong": return `Use ${issue$1.maximum} characters or fewer`;
-		case "invalidEmail": return "Enter a valid email address";
-		case "invalidPhone": return "Enter a valid phone number";
-		case "invalidPattern": return "Check the format and try again";
-		case "invalidUrl": return "Enter a valid web address";
-		case "invalidDate": return "Choose a valid date";
-		case "invalidTime": return "Choose a valid time";
-		case "invalidDateTime": return "Choose a valid date and time";
 		case "invalidNumber": return `${issue$1.label} needs a number`;
 		case "tooSmall": return `${issue$1.label} must be ${issue$1.minimum} or more`;
 		case "tooLarge": return `${issue$1.label} must be ${issue$1.maximum} or less`;
@@ -8821,7 +9282,16 @@ function fieldIssueToMessage(issue$1) {
 		case "invalidMedia": return `${issue$1.label} must be a media object with an identifier`;
 		case "invalidBoxBackground": return `${issue$1.label} must use a valid background type and matching fields`;
 		case "invalidLink": return `${issue$1.label} must be a valid link`;
+		case "invalidLayoutGrid": return issue$1.message;
 		case "invalidReference": return `${issue$1.label} must reference a valid item`;
+		case "required":
+		case "invalidDate":
+		case "invalidDateTime":
+		case "invalidEmail":
+		case "invalidPattern":
+		case "invalidPhone":
+		case "invalidTime":
+		case "invalidUrl": return simpleIssueMessages[issue$1.kind];
 		default: return assertNever$12(issue$1);
 	}
 }
@@ -8936,11 +9406,7 @@ function deriveFieldValidationPlan(field, path$3 = [field.id]) {
 		}
 		case "link": return makePlan("link", "object", field, path$3, required, commonConstraints(required, { kind: "linkObject" }));
 		case "boolean": return makePlan("boolean", "boolean", field, path$3, required, requiredConstraints(required));
-		case "repeater": return {
-			...makePlan("repeater", "array", field, path$3, required, commonConstraints(required, { kind: "arrayType" })),
-			...field.polymorphic && field.itemTypes ? { repeatedItemVariants: deriveRepeatedItemVariants(field, [...path$3, 0]) } : { repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path$3, 0]) },
-			constraints: withRepeaterItemConstraints(field, commonConstraints(required, { kind: "arrayType" }))
-		};
+		case "repeater": return deriveRepeaterFieldValidationPlan(field, path$3);
 		case "group":
 		case "modal": return {
 			...makePlan("group", "object", field, path$3, required, requiredConstraints(required)),
@@ -8957,6 +9423,27 @@ function deriveFieldValidationPlan(field, path$3 = [field.id]) {
 		default: return assertNever$12(field);
 	}
 }
+function deriveRepeaterFieldValidationPlan(field, path$3) {
+	const required = Boolean(field.required);
+	const constraints = commonConstraints(required, { kind: "arrayType" });
+	return {
+		...makePlan("repeater", "array", field, path$3, required, constraints),
+		...field.ui?.repeaterPreset === "layoutGrid" ? { layoutGrid: {
+			startNewRowField: field.ui.layoutGridStartNewRowField,
+			columns: field.ui.layoutGridColumns,
+			columnsFields: field.ui.layoutGridColumnsFields,
+			spanField: resolveRepeaterGridSpanFieldId({ id: field.ui.layoutGridSpanField }),
+			rowField: resolveRepeaterGridRowFieldId({ id: field.ui.layoutGridRowField }),
+			columnField: resolveRepeaterGridColumnFieldId({ id: field.ui.layoutGridColumnField }),
+			maxRows: field.ui.layoutGridMaxRows
+		} } : {},
+		...field.polymorphic && field.itemTypes ? { repeatedItemVariants: deriveRepeatedItemVariants(field, [...path$3, 0]) } : {
+			repeatedItemPlan: deriveNestedFieldPlans(getRepeaterFields(field), [...path$3, 0]),
+			flattenedGroupIds: getFlattenedGroupIds(field.schema?.fields ?? [])
+		},
+		constraints: withRepeaterItemConstraints(field, constraints)
+	};
+}
 function deriveFieldValidationPlans(fields$1, parentPath = []) {
 	return fields$1.map((field) => deriveFieldValidationPlan(field, [...parentPath, field.id]));
 }
@@ -9006,7 +9493,8 @@ function withRepeaterItemConstraints(field, constraints) {
 function deriveRepeatedItemVariants(field, parentPath) {
 	return Object.entries(field.itemTypes ?? {}).map(([typeId, itemType]) => ({
 		typeId,
-		fields: deriveNestedFieldPlans(getFlattenedRepeaterFields(itemType.fields), parentPath)
+		fields: deriveNestedFieldPlans(getFlattenedRepeaterFields(itemType.fields), parentPath),
+		flattenedGroupIds: getFlattenedGroupIds(itemType.fields)
 	}));
 }
 function deriveNestedFieldPlans(fields$1, parentPath) {
@@ -9016,6 +9504,11 @@ function getRepeaterFields(field) {
 	const fields$1 = field.polymorphic && field.itemTypes ? Object.values(field.itemTypes).flatMap((itemType) => itemType.fields) : field.schema?.fields ?? [];
 	return getFlattenedRepeaterFields(fields$1);
 }
+/** Only group ids absent from the actual data fields are forbidden containers. */
+function getFlattenedGroupIds(fields$1) {
+	const dataIds = new Set(getFlattenedRepeaterFields(fields$1).map((field) => field.id));
+	return fields$1.flatMap((field) => field.type === "group" && field.ui?.flattenInRepeater && !dataIds.has(field.id) ? [field.id] : []);
+}
 function getFlattenedRepeaterFields(fields$1) {
 	return fields$1.flatMap((child) => {
 		if (child.type === "group" && child.ui?.flattenInRepeater) {
@@ -9096,6 +9589,32 @@ function fieldPlanToNativeInputProps(plan) {
 function normalizeFieldInput(plan, value, options = {}) {
 	return normalizeFieldValue(plan, value, validationContext(options));
 }
+/** Drop obsolete presentation containers only when reading persisted content.
+* Flat data remains authoritative; unknown variants and legitimate groups survive.
+*/
+function normalizeLegacyStoredGroupContainers(plans, content) {
+	if (!isPlainObject$6(content)) return content;
+	const planMap = new Map(plans.map((plan) => [plan.fieldId, plan]));
+	const entries = Object.entries(content).map(([key, value]) => {
+		const plan = planMap.get(key);
+		return [key, plan ? normalizeLegacyStoredField(plan, value) : value];
+	});
+	return entries.every(([key, value]) => value === content[key]) ? content : Object.fromEntries(entries);
+}
+function normalizeLegacyStoredField(plan, value) {
+	if (plan.kind === "group") {
+		return normalizeLegacyStoredGroupContainers(selectedGroupChildPlans(plan, value), value);
+	}
+	if (plan.kind !== "repeater" || !isUnknownArray$2(value)) return value;
+	const items = value.map((item) => {
+		if (!isPlainObject$6(item)) return item;
+		const selection = selectRepeaterItemPlan(plan, item);
+		if (selection.kind !== "fields") return item;
+		const retained = selection.flattenedGroupIds.some((key) => Object.prototype.hasOwnProperty.call(item, key)) ? Object.fromEntries(Object.entries(item).filter(([key]) => !selection.flattenedGroupIds.includes(key))) : item;
+		return normalizeLegacyStoredGroupContainers(selection.fields, retained);
+	});
+	return items.every((item, index) => item === value[index]) ? value : items;
+}
 function normalizeStoredContentValues(plans, content, options = {}) {
 	if (!content || typeof content !== "object" || Array.isArray(content)) {
 		return {};
@@ -9158,7 +9677,8 @@ function normalizeStoredRepeaterItems(plan, value, ctx) {
 			return item;
 		}
 		const itemRecord = item;
-		const fields$1 = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemRecord._type)?.fields : plan.repeatedItemPlan;
+		const selection = selectRepeaterItemPlan(plan, itemRecord);
+		const fields$1 = selection.kind === "fields" ? selection.fields : undefined;
 		if (!fields$1) {
 			return item;
 		}
@@ -9215,7 +9735,8 @@ function normalizeRepeaterItems(plan, value, ctx) {
 	return value.map((item) => {
 		if (!item || typeof item !== "object" || Array.isArray(item)) return item;
 		const itemRecord = item;
-		const fields$1 = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((variant) => variant.typeId === itemRecord._type)?.fields : plan.repeatedItemPlan;
+		const selection = selectRepeaterItemPlan(plan, itemRecord);
+		const fields$1 = selection.kind === "fields" ? selection.fields : undefined;
 		if (!fields$1) return item;
 		return normalizeObjectChildren(fields$1, itemRecord, ctx);
 	});
@@ -9230,13 +9751,13 @@ function acceptsOptionalBlankAsMissing(plan, value) {
 	return plan.constraints.some((constraint) => constraint.kind === "urlFormat" || constraint.kind === "slugFormat" || constraint.kind === "emailFormat" || constraint.kind === "phoneFormat" || constraint.kind === "patternFormat");
 }
 function validateNormalizedFieldValue(plan, value, ctx) {
-	if (value === null && (ctx.allowNull || acceptsOptionalNullValue(plan))) return [];
-	if (isMissingForPlan(plan, value)) {
+	if (value === null && acceptsNullValue(plan, ctx)) return [];
+	if (isMissingForPlan(plan, value, ctx.mode)) {
 		return shouldRequireValue(plan, value, ctx) ? [requiredIssue(plan, value)] : [];
 	}
 	switch (plan.kind) {
 		case "string": return validateStringPlan(plan, value, ctx);
-		case "number": return validateNumberPlan(plan, value);
+		case "number": return validateNumberPlan(plan, value, ctx);
 		case "boolean": return typeof value === "boolean" ? [] : [issue(plan, "wrongType", { expected: "a true/false value" })];
 		case "select": return validateSelectPlan(plan, value);
 		case "richText": return isValidRichTextDoc(value) ? [] : [issue(plan, "invalidRichText")];
@@ -9260,14 +9781,18 @@ function validateMediaPlan(plan, value, ctx) {
 }
 function shouldRequireValue(plan, value, ctx) {
 	if (!plan.required || ctx.allowIncomplete) return false;
-	if (value === null && ctx.allowNull) return false;
+	if (value === null && ctx.allowNull && ctx.mode !== "storable") return false;
 	return true;
 }
+function acceptsNullValue(plan, ctx) {
+	return ctx.mode === "storable" ? !plan.required : ctx.allowNull || acceptsOptionalNullValue(plan);
+}
 function acceptsOptionalNullValue(plan) {
 	return !plan.required && (plan.kind === "media" || plan.kind === "number");
 }
-function isMissingForPlan(plan, value) {
+function isMissingForPlan(plan, value, mode) {
 	if (value === undefined) return true;
+	if (mode === "storable") return value === null || value === "";
 	if (value === null) return plan.required;
 	if (typeof value === "string" && value.trim() === "") return true;
 	if (Array.isArray(value) && value.length === 0) return true;
@@ -9286,7 +9811,7 @@ function validateStringConstraint(plan, constraint, value, ctx) {
 		return isValidIconPickerValue(value) ? [] : [issue(plan, "wrongType", { expected: "text or icon" })];
 	}
 	if (typeof value !== "string") return [issue(plan, "wrongType", { expected: "text" })];
-	if (constraint.kind === "textType" || constraint.kind === "referenceText") return [];
+	if (constraint.kind === "textType" || constraint.kind === "referenceText" || ctx.mode === "storable") return [];
 	return constraint.kind === "maxLength" ? validateAuthoredTextLength(plan, value, constraint.maximum, ctx) : validateStringFormat(plan, constraint, value);
 }
 const SIMPLE_STRING_FORMATS = {
@@ -9328,7 +9853,7 @@ function validateStringFormat(plan, constraint, value) {
 }
 /** Authoring limits govern stored block copy; resolved entry text has its own owner. */
 function validateAuthoredTextLength(plan, text$1, maximum, ctx) {
-	return ctx.mode !== "render" && maximum !== undefined && text$1.length > maximum ? [issue(plan, "tooLong", { maximum })] : [];
+	return ctx.mode !== "render" && ctx.mode !== "storable" && maximum !== undefined && text$1.length > maximum ? [issue(plan, "tooLong", { maximum })] : [];
 }
 function isValidIconPickerValue(value) {
 	if (typeof value === "string") return true;
@@ -9336,8 +9861,9 @@ function isValidIconPickerValue(value) {
 	if (value.kind === "none") return true;
 	return parseBlockIconValue(value).kind !== "none";
 }
-function validateNumberPlan(plan, value) {
+function validateNumberPlan(plan, value, ctx) {
 	if (!isValidNumber(value)) return [issue(plan, "invalidNumber")];
+	if (ctx.mode === "storable") return [];
 	return plan.constraints.flatMap((constraint) => validateNumberConstraint(plan, constraint, Number(value)));
 }
 function validateNumberConstraint(plan, constraint, value) {
@@ -9356,7 +9882,7 @@ function validateSelectPlan(plan, value) {
 }
 function validateRepeaterPlan(plan, value, ctx) {
 	if (!Array.isArray(value)) return [issue(plan, "wrongType", { expected: "a list" })];
-	const constraintIssues = plan.constraints.flatMap((constraint) => {
+	const constraintIssues = ctx.mode === "storable" ? [] : plan.constraints.flatMap((constraint) => {
 		switch (constraint.kind) {
 			case "required":
 			case "arrayType": return [];
@@ -9373,6 +9899,22 @@ function validateRepeaterPlan(plan, value, ctx) {
 	});
 	return [...constraintIssues, ...value.flatMap((item, index) => validateRepeaterItem(plan, item, index, ctx))];
 }
+/** Selects both the value fields and forbidden presentation containers together. */
+function selectRepeaterItemPlan(plan, item) {
+	if (plan.repeatedItemVariants) {
+		const variant = plan.repeatedItemVariants.find((candidate) => candidate.typeId === item._type);
+		return variant ? {
+			kind: "fields",
+			fields: variant.fields,
+			flattenedGroupIds: variant.flattenedGroupIds ?? []
+		} : { kind: "invalidType" };
+	}
+	return plan.repeatedItemPlan ? {
+		kind: "fields",
+		fields: plan.repeatedItemPlan,
+		flattenedGroupIds: plan.flattenedGroupIds ?? []
+	} : { kind: "untyped" };
+}
 function validateRepeaterItem(plan, item, index, ctx) {
 	if (!isPlainObject$6(item)) {
 		return [{
@@ -9383,9 +9925,8 @@ function validateRepeaterItem(plan, item, index, ctx) {
 			expected: "an object"
 		}];
 	}
-	const itemType = item._type;
-	const variant = plan.repeatedItemVariants ? plan.repeatedItemVariants.find((candidate) => candidate.typeId === itemType) : undefined;
-	if (plan.repeatedItemVariants && !variant) {
+	const selection = selectRepeaterItemPlan(plan, item);
+	if (selection.kind === "invalidType") {
 		return [{
 			kind: "invalidOption",
 			path: [
@@ -9397,12 +9938,27 @@ function validateRepeaterItem(plan, item, index, ctx) {
 			label: `${plan.label} item type`
 		}];
 	}
-	const fields$1 = variant?.fields ?? plan.repeatedItemPlan;
-	if (!fields$1) return [];
-	return fields$1.flatMap((childPlan) => {
+	if (selection.kind === "untyped") return [];
+	const containerIssues = validateFlattenedGroupContainers(selection.flattenedGroupIds, item, plan, index, ctx);
+	return [...containerIssues, ...selection.fields.flatMap((childPlan) => {
+		if (ctx.layoutGridCoordinates === "projected" && layoutGridCoordinateFieldIds(plan).includes(childPlan.fieldId)) return [];
 		const indexedPlan = materializeRepeaterItemPlan(childPlan, plan.path, index);
 		return validateNormalizedFieldValue(indexedPlan, item[childPlan.fieldId], ctx);
-	});
+	})];
+}
+function validateFlattenedGroupContainers(groupIds, item, plan, index, ctx) {
+	if (ctx.mode === "render") return [];
+	return groupIds.flatMap((fieldId) => Object.prototype.hasOwnProperty.call(item, fieldId) ? [{
+		kind: "wrongType",
+		path: [
+			...plan.path,
+			index,
+			fieldId
+		],
+		fieldId,
+		label: plan.label,
+		expected: "valid settings"
+	}] : []);
 }
 function validateGroupPlan(plan, value, ctx) {
 	if (!isPlainObject$6(value)) return [issue(plan, "wrongType", { expected: "an object" })];
@@ -9505,19 +10061,22 @@ function requiredIssue(plan, value) {
 	if (Array.isArray(value)) return issue(plan, "required", { emptyOrigin: "array" });
 	return issue(plan, "required");
 }
-function fieldPlanToZod(plan, options = {}) {
-	const ctx = validationContext(options);
+function fieldPlanToZod(plan, options = {}, layoutGridCoordinates = "validate") {
+	const ctx = {
+		...validationContext(options),
+		layoutGridCoordinates
+	};
 	return z.any().transform((value) => normalizeFieldValue(plan, value, ctx)).superRefine((value, zodCtx) => {
-		for (const validationIssue of validateNormalizedFieldValue(plan, value, ctx)) {
+		validateNormalizedFieldValue(plan, value, ctx).forEach((validationIssue) => {
 			addFieldIssueToZodContext(zodCtx, validationIssue, plan.path);
-		}
+		});
 	});
 }
 function fieldPresenceForPlan(plan) {
 	return plan.required ? { kind: "required" } : { kind: "optional" };
 }
-function fieldPlanToObjectPropertyZod(plan, options = {}) {
-	const schema = fieldPlanToZod(plan, options);
+function fieldPlanToObjectPropertyZod(plan, options = {}, layoutGridCoordinates = "validate") {
+	const schema = fieldPlanToZod(plan, options, layoutGridCoordinates);
 	const presence = fieldPresenceForPlan(plan);
 	switch (presence.kind) {
 		case "required": return schema;
@@ -9526,11 +10085,14 @@ function fieldPlanToObjectPropertyZod(plan, options = {}) {
 	}
 }
 /** Validate stored or runtime fields without applying editor/write normalization. */
-function fieldPlanToStrictObjectPropertyZod(plan, mode = "strict") {
-	const ctx = strictValidationContext({
-		allowNull: false,
-		mode
-	});
+function fieldPlanToStrictObjectPropertyZod(plan, mode = "strict", layoutGridCoordinates = "validate") {
+	const ctx = {
+		...strictValidationContext({
+			allowNull: false,
+			mode
+		}),
+		layoutGridCoordinates
+	};
 	const schema = z.any().superRefine((value, zodCtx) => {
 		validateNormalizedFieldValue(plan, value, ctx).forEach((validationIssue) => {
 			addFieldIssueToZodContext(zodCtx, validationIssue, plan.path);
@@ -9538,76 +10100,35 @@ function fieldPlanToStrictObjectPropertyZod(plan, mode = "strict") {
 	});
 	return plan.required ? schema : schema.optional();
 }
-function addFieldIssueToZodContext(zodCtx, validationIssue, rootPath) {
-	const message = fieldIssueToMessage(validationIssue);
-	const path$3 = relativeZodIssuePath(validationIssue.path, rootPath);
-	const issuePath = path$3.length > 0 ? { path: toZodIssuePath(path$3) } : {};
-	switch (validationIssue.kind) {
-		case "required":
-			if (validationIssue.emptyOrigin) {
-				zodCtx.addIssue({
-					...issuePath,
-					code: "too_small",
-					origin: validationIssue.emptyOrigin,
-					minimum: 1,
-					inclusive: true,
-					message
-				});
-				return;
-			}
-			zodCtx.addIssue({
-				...issuePath,
-				code: "invalid_type",
-				expected: "nonoptional",
-				message
-			});
-			return;
-		case "tooLong":
-			zodCtx.addIssue({
-				...issuePath,
-				code: "too_big",
-				origin: "string",
-				maximum: validationIssue.maximum,
-				inclusive: true,
-				message
-			});
-			return;
-		case "invalidOption":
-			zodCtx.addIssue({
-				...issuePath,
-				code: "invalid_value",
-				values: [],
-				message
-			});
-			return;
-		case "wrongType":
-		case "invalidEmail":
-		case "invalidPhone":
-		case "invalidPattern":
-		case "invalidUrl":
-		case "invalidDate":
-		case "invalidTime":
-		case "invalidDateTime":
-		case "invalidNumber":
-		case "tooSmall":
-		case "tooLarge":
-		case "invalidSlug":
-		case "tooFewItems":
-		case "tooManyItems":
-		case "invalidRichText":
-		case "invalidInlineText":
-		case "invalidMedia":
-		case "invalidBoxBackground":
-		case "invalidLink":
-		case "invalidReference":
-			zodCtx.addIssue({
-				...issuePath,
-				code: "custom",
-				message
-			});
-			return;
-		default: assertNever$12(validationIssue);
-	}
+function fieldIssueToZodDetail(issue$1) {
+	if (issue$1.kind === "required") return issue$1.emptyOrigin ? {
+		code: "too_small",
+		origin: issue$1.emptyOrigin,
+		minimum: 1,
+		inclusive: true
+	} : {
+		code: "invalid_type",
+		expected: "nonoptional"
+	};
+	if (issue$1.kind === "tooLong") return {
+		code: "too_big",
+		origin: "string",
+		maximum: issue$1.maximum,
+		inclusive: true
+	};
+	if (issue$1.kind === "invalidOption") return {
+		code: "invalid_value",
+		values: []
+	};
+	return { code: "custom" };
+}
+function addFieldIssueToZodContext(zodCtx, issue$1, rootPath) {
+	const detail = fieldIssueToZodDetail(issue$1);
+	zodCtx.addIssue({
+		...detail,
+		path: toZodIssuePath(relativeZodIssuePath(issue$1.path, rootPath)),
+		message: fieldIssueToMessage(issue$1)
+	});
 }
 function relativeZodIssuePath(path$3, rootPath) {
 	return startsWithFieldPath(path$3, rootPath) ? path$3.slice(rootPath.length) : path$3;
@@ -9668,7 +10189,7 @@ function sameFieldPath(left, right) {
 function validateManifestValues(fields$1, values, options = {}) {
 	const plans = deriveFieldValidationPlans(fields$1);
 	const normalized = normalizeStoredContentValues(plans, values, options);
-	return plans.flatMap((plan) => validateFieldValue(plan, normalized[plan.fieldId], options));
+	return [...plans.flatMap((plan) => validateFieldValue(plan, normalized[plan.fieldId], options)), ...validateLayoutGridPlans(plans, normalized)];
 }
 function compilePattern(pattern) {
 	try {
@@ -9771,6 +10292,63 @@ function isEmptyRichTextDoc(value) {
 	return first?.type === "paragraph" && (!Array.isArray(first.content) || first.content.length === 0);
 }
 
+//#endregion
+//#region ../blocks/src/system/manifest/fieldValidation/layoutGridRendering.ts
+function invalidCoordinateIds(plan, items, itemIds) {
+	const ids = layoutGridCoordinateFieldIds(plan);
+	return items.flatMap((item, index) => {
+		const row$1 = layoutGridRecord(item);
+		const invalid$1 = row$1 !== null && resolveLayoutGridItemPlans(plan, row$1).some((field) => ids.includes(field.fieldId) && !fieldPlanToStrictObjectPropertyZod(field).safeParse(row$1[field.fieldId]).success);
+		return invalid$1 ? [itemIds?.[index] ?? String(index)] : [];
+	});
+}
+/** Shared raw-coordinate admission for editor and public rendering; retains diagnostics. */
+function admitLayoutGridForPlan(plan, value, rootValues, ids) {
+	const layout = buildLayoutGridForPlan(plan, value, rootValues, ids);
+	const invalidIds = invalidCoordinateIds(plan, value, ids);
+	return layout && invalidIds.length > 0 ? {
+		...layout,
+		hasInvalidItems: true,
+		invalidCoordinateIds: invalidIds
+	} : layout;
+}
+function projectGrid(plan, value, rootValues) {
+	const grid$5 = plan.layoutGrid;
+	const layout = admitLayoutGridForPlan(plan, value, rootValues);
+	if (!grid$5 || !layout) return value;
+	const authored = layout;
+	const projected = projectRepeaterGridLayoutForRendering(authored);
+	if (projected === authored) return value;
+	return value.map((item, index) => {
+		const row$1 = layoutGridRecord(item);
+		const placement = projected.byId[String(index)];
+		if (!row$1 || !placement) return item;
+		const spanPlan = resolveLayoutGridItemPlans(plan, row$1).find((field) => field.fieldId === grid$5.spanField);
+		return {
+			...row$1,
+			[grid$5.spanField]: spanPlan?.kind === "number" ? placement.span : String(placement.span),
+			[grid$5.rowField]: placement.row,
+			[grid$5.columnField]: placement.colStart
+		};
+	});
+}
+/** Only layout coordinates are projected. Array order, item data and media references remain intact. */
+function projectLayoutGridPlansForRendering(plans, value, rootValues = layoutGridRecord(value) ?? {}) {
+	const values = layoutGridRecord(value);
+	if (!values) return value;
+	return plans.reduce((projected, plan) => {
+		const fieldValue = projected[plan.fieldId];
+		const next = plan.kind === "group" ? projectLayoutGridPlansForRendering(allGroupChildPlans(plan), fieldValue, rootValues) : plan.kind === "repeater" && Array.isArray(fieldValue) ? projectGrid(plan, fieldValue, rootValues).map((item) => {
+			const row$1 = layoutGridRecord(item);
+			return row$1 ? projectLayoutGridPlansForRendering(resolveLayoutGridItemPlans(plan, row$1), row$1, rootValues) : item;
+		}) : fieldValue;
+		return next === fieldValue ? projected : {
+			...projected,
+			[plan.fieldId]: next
+		};
+	}, values);
+}
+
 //#endregion
 //#region ../blocks/src/system/manifest/validation.ts
 const compiledManifestContentContract = Symbol("compiledManifestContentContract");
@@ -9802,6 +10380,7 @@ function compileManifestContentContract(manifestOrFields, options = {}) {
 	return Object.freeze({ [compiledManifestContentContract]: Object.freeze({
 		plans,
 		strictStoredSchema,
+		renderSourceSchema: deriveStrictContentZodFromPlans(plans, "render-source"),
 		writeSchema: deriveNormalizedContentZodFromPlans(plans, strictOptions, normalizeManifestContentForWrite).superRefine((value, ctx) => {
 			if (options.unknownFields !== "reject") return;
 			unknownManifestFieldPaths(plans, value).forEach((path$3) => {
@@ -9817,6 +10396,11 @@ function compileManifestContentContract(manifestOrFields, options = {}) {
 			allowIncomplete: true,
 			mode: "draft"
 		}, normalizeStoredContentValues),
+		renderDraftSchema: deriveNormalizedContentZodFromPlans(plans, {
+			allowNull: true,
+			allowIncomplete: true,
+			mode: "draft"
+		}, normalizeStoredContentValues, false),
 		renderSchema: deriveStrictContentZodFromPlans(plans, "render"),
 		findNonPortableMediaPaths: (content) => findNonPortableMediaPaths(plans, content)
 	}) });
@@ -9855,7 +10439,8 @@ function findNonPortableManifestMediaPaths(contract, content) {
 /** Strictly admits already-persisted content without repairing it. */
 function admitStoredManifestContent(contract, content) {
 	const state = contract[compiledManifestContentContract];
-	const nonPortablePaths = state.findNonPortableMediaPaths(content);
+	const normalized = normalizeLegacyStoredGroupContainers(state.plans, content);
+	const nonPortablePaths = state.findNonPortableMediaPaths(normalized);
 	if (nonPortablePaths.length > 0) {
 		return {
 			ok: false,
@@ -9865,10 +10450,32 @@ function admitStoredManifestContent(contract, content) {
 			}
 		};
 	}
-	const parsed = state.strictStoredSchema.safeParse(content);
+	const parsed = state.strictStoredSchema.safeParse(normalized);
 	return parsed.success ? {
 		ok: true,
-		value: content
+		value: normalized
+	} : {
+		ok: false,
+		error: zodAdmissionError(parsed.error)
+	};
+}
+/** Public reads alone may project invalid grid geometry. All other stored-shape and portability checks remain strict. */
+function admitStoredManifestContentForRendering(contract, content) {
+	const state = contract[compiledManifestContentContract];
+	const normalized = normalizeLegacyStoredGroupContainers(state.plans, content);
+	const paths = state.findNonPortableMediaPaths(normalized);
+	if (paths.length > 0) return {
+		ok: false,
+		error: {
+			kind: "non_portable_media",
+			paths
+		}
+	};
+	const projected = projectLayoutGridPlansForRendering(state.plans, normalized);
+	const parsed = state.renderSourceSchema.safeParse(projected);
+	return parsed.success ? {
+		ok: true,
+		value: projected
 	} : {
 		ok: false,
 		error: zodAdmissionError(parsed.error)
@@ -9916,6 +10523,24 @@ function validateManifestDraft(contract, data) {
 		issues: [firstIssue, ...remainingIssues]
 	};
 }
+/** Public template bases may be incomplete until bindings resolve; only grid geometry is projected. */
+function validateManifestDraftForRendering(contract, data) {
+	const state = contract[compiledManifestContentContract];
+	const projected = projectLayoutGridPlansForRendering(state.plans, data);
+	const parsed = state.renderDraftSchema.safeParse(projected);
+	if (parsed.success) return {
+		kind: "previewable",
+		data: projected,
+		issues: []
+	};
+	const [firstIssue, ...remainingIssues] = zodAdmissionIssues(parsed.error);
+	if (!firstIssue) throw new Error("Render draft validation failed without an issue");
+	return {
+		kind: "invalid",
+		data: projected,
+		issues: [firstIssue, ...remainingIssues]
+	};
+}
 /**
 * Checks whether a raw editor candidate is schema-ready for the effectful
 * media-resolution/write boundary without granting a stored proof.
@@ -9942,8 +10567,9 @@ function validateManifestWriteCandidate(contract, data) {
 * the resulting render shape before granting the renderable proof.
 */
 function deriveRenderableManifestContent(contract, stored, project) {
-	const projected = project(stored);
-	const parsed = contract[compiledManifestContentContract].renderSchema.safeParse(projected);
+	const state = contract[compiledManifestContentContract];
+	const projected = projectLayoutGridPlansForRendering(state.plans, normalizeLegacyStoredGroupContainers(state.plans, project(stored)));
+	const parsed = state.renderSchema.safeParse(projected);
 	return parsed.success ? {
 		ok: true,
 		value: projected
@@ -9958,33 +10584,50 @@ function deriveRenderableManifestContent(contract, stored, project) {
 * grants a stored proof, so hydrated media cannot flow back to persistence.
 */
 function admitTransportedRenderableManifestContent(contract, content) {
-	const parsed = contract[compiledManifestContentContract].renderSchema.safeParse(content);
+	const state = contract[compiledManifestContentContract];
+	const projected = projectLayoutGridPlansForRendering(state.plans, content);
+	const parsed = state.renderSchema.safeParse(projected);
 	return parsed.success ? {
 		ok: true,
-		value: content
+		value: projected
 	} : {
 		ok: false,
 		error: zodAdmissionError(parsed.error)
 	};
 }
-function deriveNormalizedContentZodFromPlans(plans, options, normalize$4) {
+function deriveNormalizedContentZodFromPlans(plans, options, normalize$4, validateLayoutGrids = true) {
 	const isDraft = options.mode === "draft";
-	const baseSchema = deriveContentZodFromPlans(plans, options);
+	const baseSchema = deriveContentZodFromPlans(plans, options, validateLayoutGrids);
 	if (isDraft) {
 		return z.preprocess((content) => preprocessEmptyValues(normalize$4(plans, content, options)), baseSchema);
 	}
 	return z.preprocess((content) => normalize$4(plans, content, options), baseSchema);
 }
-function deriveContentZodFromPlans(plans, options) {
-	const shape = {};
-	for (const plan of plans) {
-		shape[plan.fieldId] = fieldPlanToObjectPropertyZod(plan, options);
-	}
-	return z.object(shape).catchall(z.unknown()).passthrough();
+function deriveContentZodFromPlans(plans, options, validateLayoutGrids = true) {
+	const shape = Object.fromEntries(plans.map((plan) => [plan.fieldId, fieldPlanToObjectPropertyZod(plan, options, validateLayoutGrids ? "validate" : "projected")]));
+	return z.object(shape).catchall(z.unknown()).passthrough().superRefine((values, ctx) => {
+		if (!validateLayoutGrids) return;
+		validateLayoutGridPlans(plans, values).forEach((issue$1) => {
+			ctx.addIssue({
+				code: "custom",
+				path: [...issue$1.path],
+				message: issue$1.message
+			});
+		});
+	});
 }
 function deriveStrictContentZodFromPlans(plans, mode = "strict") {
-	const shape = Object.fromEntries(plans.map((plan) => [plan.fieldId, fieldPlanToStrictObjectPropertyZod(plan, mode)]));
-	return z.object(shape).catchall(z.unknown()).passthrough();
+	const shape = Object.fromEntries(plans.map((plan) => [plan.fieldId, fieldPlanToStrictObjectPropertyZod(plan, mode === "render" ? "render" : "strict", mode === "strict" ? "validate" : "projected")]));
+	return z.object(shape).catchall(z.unknown()).passthrough().superRefine((values, ctx) => {
+		if (mode !== "strict") return;
+		validateLayoutGridPlans(plans, values).forEach((issue$1) => {
+			ctx.addIssue({
+				code: "custom",
+				path: [...issue$1.path],
+				message: issue$1.message
+			});
+		});
+	});
 }
 function derivePlansFromManifestOrFields(manifestOrFields) {
 	const fields$1 = Array.isArray(manifestOrFields) ? manifestOrFields : manifestOrFields.fields ?? [];
@@ -12306,6 +12949,7 @@ function styledSection(config$1) {
 		baseClass,
 		spacing,
 		fullWidthPath,
+		photoPaintsGround: renderBackgroundImage,
 		skinSlot: config$1.skinSlot
 	}), [renderedBackgroundNode, ...childrenArray]);
 }
@@ -12317,7 +12961,10 @@ function sectionAppearanceProps(input) {
 			from: `${input.bindFrom}.background`,
 			transforms: [{
 				id: "sectionStyles.resolveColorsStyle",
-				options: { fallbackToken: input.background }
+				options: {
+					fallbackToken: input.background,
+					photoPaintsGround: input.photoPaintsGround
+				}
 			}]
 		} },
 		className: { $bind: {
@@ -13487,70 +14134,6 @@ function applyAlpha(color, opacity) {
 	return color;
 }
 
-//#endregion
-//#region ../blocks/src/system/fields/backgroundContent.ts
-/**
-* Replaces only the background medium while retaining presentation fields that
-* are valid for the resulting image variant. Stale color/gradient tab state is
-* never copied into the new value.
-*/
-function replaceBackgroundWithImage(value, image, defaults = {}) {
-	const current = parseBackgroundContent(value);
-	let candidate;
-	if (current?.type === "image") {
-		const { type: _type, image: _image, ...presentation } = current;
-		candidate = {
-			...defaults,
-			...presentation,
-			type: "image",
-			image
-		};
-	} else if (current?.type === "video") {
-		const { type: _type, image: _image, showVideoOnMobile: _mobile, ...presentation } = current;
-		candidate = {
-			...defaults,
-			...presentation,
-			type: "image",
-			image
-		};
-	} else {
-		candidate = {
-			...defaults,
-			...commonPresentation(current),
-			type: "image",
-			image
-		};
-	}
-	const canonical$1 = boxBackgroundSchema.parse(candidate);
-	if (canonical$1.type !== "image") {
-		throw new Error("Image background construction produced a non-image variant");
-	}
-	return canonical$1;
-}
-function parseBackgroundContent(value) {
-	const result = boxBackgroundSchema.safeParse(value);
-	return result.success ? result.data : null;
-}
-function commonPresentation(background) {
-	return background ? {
-		contentOwner: background.contentOwner,
-		textColor: background.textColor,
-		headingColor: background.headingColor,
-		linkColor: background.linkColor,
-		supportingColor: background.supportingColor
-	} : {};
-}
-function parseBackgroundOverlay(value) {
-	const result = boxBackgroundOverlaySchema.safeParse(value);
-	return result.success ? result.data : undefined;
-}
-/** Rendering accepts explicit application sources separately from stored references. */
-const runtimeBackgroundContentSchema = runtimeBoxBackgroundSchema;
-function parseRuntimeBackgroundContent(value) {
-	const result = runtimeBackgroundContentSchema.safeParse(value);
-	return result.success ? result.data : null;
-}
-
 //#endregion
 //#region ../blocks/src/system/transforms/registry/_utils/themeColorResolution.ts
 function resolveBackgroundColorValue(value, context) {
@@ -13578,7 +14161,7 @@ function resolveSurfaceForegroundStyles(value, context, options) {
 	const key = JSON.stringify([
 		value,
 		context.proseHoverCandidate,
-		options?.fallbackToken,
+		options,
 		context.data?._lookSlots !== undefined
 	]);
 	const cache = sectionSurfaceCache.get(context.theme) ?? new Map();
@@ -13595,9 +14178,13 @@ function resolveSurfaceForegroundStyles(value, context, options) {
 }
 /** Cache only the owner's result; no foreground or button rules live here. */
 function resolveRuntimeSectionSurface(value, context, options) {
+	const background = resolveSectionBackground(parseCanonicalRuntimeBackground({ _sectionStyles: { background: value } }), null, undefined, {
+		paintsGround: options?.photoPaintsGround !== false,
+		fallbackToken: options?.fallbackToken
+	});
 	return resolveSurface({
 		kind: "section",
-		background: parseBackgroundContent(value)
+		background: sectionForegroundBackground(background, context.theme.palette)
 	}, {
 		palette: context.theme.palette,
 		buttonSystem: context.theme.buttons,
@@ -13622,6 +14209,70 @@ function surfaceInkStyles(foreground, palette) {
 	};
 }
 
+//#endregion
+//#region ../blocks/src/system/fields/backgroundContent.ts
+/**
+* Replaces only the background medium while retaining presentation fields that
+* are valid for the resulting image variant. Stale color/gradient tab state is
+* never copied into the new value.
+*/
+function replaceBackgroundWithImage(value, image, defaults = {}) {
+	const current = parseBackgroundContent(value);
+	let candidate;
+	if (current?.type === "image") {
+		const { type: _type, image: _image, ...presentation } = current;
+		candidate = {
+			...defaults,
+			...presentation,
+			type: "image",
+			image
+		};
+	} else if (current?.type === "video") {
+		const { type: _type, image: _image, showVideoOnMobile: _mobile, ...presentation } = current;
+		candidate = {
+			...defaults,
+			...presentation,
+			type: "image",
+			image
+		};
+	} else {
+		candidate = {
+			...defaults,
+			...commonPresentation(current),
+			type: "image",
+			image
+		};
+	}
+	const canonical$1 = boxBackgroundSchema.parse(candidate);
+	if (canonical$1.type !== "image") {
+		throw new Error("Image background construction produced a non-image variant");
+	}
+	return canonical$1;
+}
+function parseBackgroundContent(value) {
+	const result = boxBackgroundSchema.safeParse(value);
+	return result.success ? result.data : null;
+}
+function commonPresentation(background) {
+	return background ? {
+		contentOwner: background.contentOwner,
+		textColor: background.textColor,
+		headingColor: background.headingColor,
+		linkColor: background.linkColor,
+		supportingColor: background.supportingColor
+	} : {};
+}
+function parseBackgroundOverlay(value) {
+	const result = boxBackgroundOverlaySchema.safeParse(value);
+	return result.success ? result.data : undefined;
+}
+/** Rendering accepts explicit application sources separately from stored references. */
+const runtimeBackgroundContentSchema = runtimeBoxBackgroundSchema;
+function parseRuntimeBackgroundContent(value) {
+	const result = runtimeBackgroundContentSchema.safeParse(value);
+	return result.success ? result.data : null;
+}
+
 //#endregion
 //#region ../blocks/src/system/transforms/registry/_utils/boxStyleClassNames.ts
 /**
@@ -17857,7 +18508,7 @@ function splitLayoutWith(children) {
 				children
 			}
 		}),
-		renderBackgroundImage: false,
+		renderBackgroundImage: heroPhotoPaintsGround("split"),
 		baseClass: ""
 	});
 }
@@ -17873,7 +18524,7 @@ const lookPhoto = el("figure", lookSlot("media"), [media({
 const lookCopy = el("div", lookSlot("copy"), heroContentNodes);
 const heroLookLayout = (children) => styledSection({
 	baseClass: "",
-	renderBackgroundImage: false,
+	renderBackgroundImage: heroPhotoPaintsGround("headline-row"),
 	children: styledContainer({ children: el("div", lookSlot("frame"), children) })
 });
 const headlineRowLayout = heroLookLayout([
@@ -18921,8 +19572,24 @@ const blogListingBlockDefinition = {
 //#endregion
 //#region ../blocks/src/system/blocks/cta-full.ts
 const ctaComposition = composeFragments([{ fragment: ctaCopyFragment }, { fragment: ctaRowFragment }]);
+const figureLayout = styledSection({
+	children: sectionContainer([el("div", lookSlot("layout"), [el("div", lookSlot("figure"), [text({
+		as: "p",
+		...lookSlot("figure-value")
+	}, when("content.figure"), bind("content.figure")), text({
+		as: "p",
+		...lookSlot("figure-label")
+	}, when("content.figureNote"), bind("content.figureNote"))], when("content.figure")), el("div", lookSlot("copy"), [...ctaComposition.layout])])], {
+		gap: "md",
+		className: "rb-relative"
+	}),
+	baseClass: ""
+});
 const ctaFullConfig = {
-	variantMeaning: { kind: "arrangement" },
+	variantMeaning: {
+		kind: "arrangement",
+		lookOnlyKeys: ["figure"]
+	},
 	id: "block.cta-full",
 	title: "Full-width CTA",
 	category: "marketing",
@@ -18934,6 +19601,21 @@ const ctaFullConfig = {
 		fragment: ctaRowFragment,
 		fieldPriority: 2
 	}],
+	additionalFields: [parseFieldDefinition({
+		id: "figure",
+		type: "text",
+		label: "Big figure",
+		help: "A short number or price, like £12 or 6 weeks.",
+		required: false,
+		defaultValue: ""
+	}), parseFieldDefinition({
+		id: "figureNote",
+		type: "text",
+		label: "Under the figure",
+		help: "A few words under it, like 'your first class'.",
+		required: false,
+		defaultValue: ""
+	})],
 	layout: styledSection({
 		children: props(lookSlot("copy"))(sectionContainer(ctaComposition.layout, {
 			gap: "md",
@@ -18941,6 +19623,7 @@ const ctaFullConfig = {
 		})),
 		baseClass: ""
 	}),
+	variants: { figure: figureLayout },
 	description: "Centered call to action with optional background image.",
 	tags: [
 		"cta",
@@ -19786,6 +20469,21 @@ const splitHeadingColumnsLayout = styledSection({
 	}),
 	baseClass: ""
 });
+const openAnswer = el("div", lookSlot("item"), [text({
+	as: "h3",
+	...lookSlot("item-title")
+}, bind("faqItem.question")), richText({ ...lookSlot("item-text") }, when("faqItem.answer"), bind("faqItem.answer"))], repeat("content.items", "faqItem", { indexName: "faqIndex" }));
+const openLayout = styledSection({
+	children: styledContainer({
+		baseClassName: "rb-relative rb-isolate",
+		children: stack({
+			gap: "lg",
+			className: "rb-w-full",
+			...lookSlot("layout")
+		}, [headingLayout, el("div", lookSlot("items"), [openAnswer])])
+	}),
+	baseClass: ""
+});
 const faqManifest = createBlockManifest({
 	id: "block.faq",
 	title: "FAQ",
@@ -19809,9 +20507,13 @@ const faqManifest = createBlockManifest({
 		default: defaultLayout,
 		"two-column": twoColumnLayout,
 		"question-columns": questionColumnsLayout,
-		"split-heading-columns": splitHeadingColumnsLayout
+		"split-heading-columns": splitHeadingColumnsLayout,
+		open: openLayout
+	},
+	variantMeaning: {
+		kind: "arrangement",
+		lookOnlyKeys: ["open"]
 	},
-	variantMeaning: { kind: "arrangement" },
 	defaultVariant: "default",
 	variantOptions: {
 		default: {
@@ -24634,7 +25336,7 @@ const publicEventAttendanceModeSchema = z.enum(["in_person", "online"]);
 const publicEventAttendanceModeAvailabilitySchema = z.object({
 	mode: publicEventAttendanceModeSchema,
 	capacity: z.number().nullable(),
-	registeredCount: z.number(),
+	registeredCount: z.number().nullable(),
 	availableSpots: z.number().nullable(),
 	waitlistEnabled: z.boolean()
 });
@@ -24799,7 +25501,7 @@ const publicEventBaseSchema = z.object({
 	startsAt: z.string(),
 	endsAt: z.string(),
 	capacity: z.number().nullable(),
-	registeredCount: z.number(),
+	registeredCount: z.number().nullable(),
 	availableSpots: z.number().nullable(),
 	waitlistEnabled: z.boolean(),
 	venue: eventVenueSchema.nullable(),
@@ -25204,6 +25906,10 @@ function getEventAvailability(event) {
 			isFull: false
 		};
 	}
+	if (event.registeredCount === null) return {
+		available: 0,
+		isFull: true
+	};
 	const available = event.availableSpots ?? event.capacity - event.registeredCount;
 	if (available <= 0) {
 		return {
@@ -25259,12 +25965,12 @@ function lowCapacityThreshold(capacity) {
 }
 function getRemainingPlaces(source) {
 	const { available, isFull: isFull$1 } = getEventAvailability(source);
-	if (available === null || source.capacity === null) return { kind: "unlimited" };
+	if (available === null) return { kind: "unlimited" };
 	if (isFull$1) return {
 		kind: "full",
 		waitlist: canJoinEventWaitlist(source)
 	};
-	if (available <= lowCapacityThreshold(source.capacity)) {
+	if (source.capacity !== null && available <= lowCapacityThreshold(source.capacity)) {
 		return {
 			kind: "low",
 			remaining: available
@@ -25563,6 +26269,30 @@ function createHostedBlockApiConfig(input) {
 	};
 }
 
+//#endregion
+//#region ../blocks/src/system/runtime/nodes/events/shared/eventScheduleSummary.ts
+function bookingDateLocale(siteTimeZone) {
+	return inferSiteDateLocale(resolveBookingBusinessTimeZone(siteTimeZone));
+}
+/** A stored local clock has no date or DST offset; UTC preserves its digits. */
+function formatBookingSchedulePresentation(event) {
+	const summary = event.scheduleSummary;
+	if (!summary) return null;
+	const start = summary.startTime ? parseUtcIsoDateTimeString(`1970-01-01T${summary.startTime}:00Z`) : null;
+	const time = start?.ok ? formatTime$1(start.value, {
+		timeZone: resolveBookingTimeZoneId("UTC"),
+		locale: bookingDateLocale(event.siteTimeZone)
+	}, { zone: "omit" }) : null;
+	return {
+		text: [summary.recurrenceDescription, time].filter(Boolean).join(", "),
+		clock: time
+	};
+}
+/** Text-only consumers delegate to the same authored-clock presentation. */
+function formatBookingScheduleSummary(event) {
+	return formatBookingSchedulePresentation(event)?.text ?? null;
+}
+
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/events/domain/bookability.ts
 /**
@@ -27786,8 +28516,13 @@ function buildCalendarViewport(input) {
 }
 /** Tick digits are civil clock values, not session instants. */
 function formatEventHourLabel(hour, timeZone) {
-	return formatTime$1(toUtcIsoDateTimeString(`2000-01-01T${String(hour % 24).padStart(2, "0")}:00:00Z`), {
-		locale: eventDateLocale(timeZone),
+	return formatEventClockLabel(`${String(hour % 24).padStart(2, "0")}:00`, eventDateLocale(timeZone));
+}
+/** Weekly cadence and tick clocks are civil values; UTC only carries their components. */
+function formatEventClockLabel(value, locale) {
+	const clock = parseLocalScheduleTime(value);
+	return formatTime$1(toUtcIsoDateTimeString(new Date(Date.UTC(2e3, 0, 1, clock.hour, clock.minute)).toISOString()), {
+		locale,
 		timeZone: resolveBookingBusinessTimeZone("UTC")
 	}, { zone: "omit" });
 }
@@ -28206,9 +28941,9 @@ function findBookedEvent(events, identity) {
 
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/ticketSelectionLines.ts
-/** Ticket selection requests a quote; only the server admits a booking. */
-function canRequestTicketOption(availability) {
-	return availability.kind === "available" || availability.reason === "sold_out" || availability.reason === "overallCapacityUnavailable";
+/** Waitlists request places; bookings can only request currently available capacity. */
+function canRequestTicketOption(availability, purpose) {
+	return availability.kind === "available" || purpose === "waitlist" && (availability.reason === "sold_out" || availability.reason === "overallCapacityUnavailable");
 }
 function normalizeTicketSelectionLines(lines) {
 	const quantitiesByTicketType = new Map();
@@ -28236,8 +28971,20 @@ function getSingleSelectedPricingOptionId(lines) {
 function hasValidPricingOptionSelection(input) {
 	if (!input.selectionRequired) return true;
 	if (input.lines.length === 0) return false;
-	const availableOptionIds = new Set(input.visibleOptions.filter((option) => canRequestTicketOption(option.availability)).map((option) => option.pricingOptionId));
-	return input.lines.every((line) => line.pricingOptionId !== null && availableOptionIds.has(line.pricingOptionId));
+	const totalSelectedQuantity = getTicketSelectionTotal(input.lines);
+	return input.lines.every((line) => {
+		const option = input.visibleOptions.find((option$1) => option$1.pricingOptionId === line.pricingOptionId);
+		return option !== undefined && line.quantity <= getTicketTypeLineMax({
+			currentQuantity: line.quantity,
+			totalSelectedQuantity,
+			maxTickets: input.maxTickets,
+			purpose: input.purpose,
+			pricingOptionId: option.pricingOptionId,
+			availability: option.availability,
+			heldPlacesBySelection: input.heldPlacesBySelection,
+			overallRemainingPlaces: input.overallRemainingPlaces
+		});
+	});
 }
 function setTicketLineQuantity(input) {
 	const nextQuantity = Math.max(0, Math.floor(input.quantity));
@@ -28251,9 +28998,19 @@ function setTicketLineQuantity(input) {
 	}];
 }
 function getTicketTypeLineMax(input) {
+	if (!canRequestTicketOption(input.availability, "waitlist")) return 0;
 	const otherSelectedQuantity = input.totalSelectedQuantity - input.currentQuantity;
 	const maxByBlock = input.maxTickets - otherSelectedQuantity;
-	return Math.max(0, maxByBlock);
+	if (input.purpose === "waitlist") return Math.max(0, maxByBlock);
+	const heldPlaces = input.heldPlacesBySelection ?? [];
+	const heldForType = getTicketLineQuantity(heldPlaces, input.pricingOptionId);
+	const publicRemaining = canRequestTicketOption(input.availability, input.purpose) ? input.availability.remainingPlaces ?? Infinity : 0;
+	const maxByOverall = (input.overallRemainingPlaces ?? Infinity) + getTicketSelectionTotal(heldPlaces) - otherSelectedQuantity;
+	return Math.max(0, Math.min(maxByBlock, publicRemaining + heldForType, maxByOverall));
+}
+/** Holds belong to the original event, mode and ticket types, not the edited draft. */
+function getHeldPlacesBySelection(current, held) {
+	return held?.selectionId === current.selectionId && held?.attendanceMode === current.attendanceMode ? held.lines : [];
 }
 
 //#endregion
@@ -30174,20 +30931,6 @@ function formatTime$2(isoTimestamp, options) {
 	const { context, zone } = bookingContext(options);
 	return instant.ok ? formatTime$1(instant.value, context, { zone }) : isoTimestamp;
 }
-function bookingDateLocale(siteTimeZone) {
-	return inferSiteDateLocale(resolveBookingBusinessTimeZone(siteTimeZone));
-}
-/** A stored local clock has no date or DST offset; UTC preserves its digits. */
-function formatBookingScheduleSummary(event) {
-	const summary = event.scheduleSummary;
-	if (!summary) return null;
-	const start = summary.startTime ? parseUtcIsoDateTimeString(`1970-01-01T${summary.startTime}:00Z`) : null;
-	const time = start?.ok ? formatTime$1(start.value, {
-		timeZone: resolveBookingTimeZoneId("UTC"),
-		locale: bookingDateLocale(event.siteTimeZone)
-	}, { zone: "omit" }) : null;
-	return [summary.recurrenceDescription, time].filter(Boolean).join(", ");
-}
 /** Variant meaning is closed here; core owns the resulting typography. */
 const BOOKING_DATE_PRESENTATIONS = {
 	day: {
@@ -30436,10 +31179,34 @@ function getVisibleTicketTypes(input) {
 		pricingOptionId: id
 	})) : [];
 	const source = input.eligibility?.ticketTypes ?? eventTicketTypes;
-	return source.filter((ticketType) => ticketType.isActive && (!input.selectedAttendanceMode || (ticketType.attendanceScope ?? "both") === "both" || (ticketType.attendanceScope ?? "both") === input.selectedAttendanceMode));
+	const selectedIds = new Set(input.ticketSelections?.map((line) => line.pricingOptionId));
+	return source.map((ticketType) => ticketTypeForSelectionMode(ticketType, input.selectedAttendanceMode)).filter((ticketType) => selectedIds.has(ticketType.pricingOptionId) || ticketType.isActive && ticketTypeMatchesMode(ticketType, input.selectedAttendanceMode));
+}
+function ticketTypeForSelectionMode(ticketType, mode) {
+	if (!ticketType.isActive) return {
+		...ticketType,
+		availability: {
+			kind: "unavailable",
+			reason: "inactive",
+			remainingPlaces: ticketType.availability.remainingPlaces
+		}
+	};
+	if (!ticketTypeMatchesMode(ticketType, mode)) return {
+		...ticketType,
+		availability: {
+			kind: "unavailable",
+			reason: "attendance_mode_unavailable",
+			remainingPlaces: ticketType.availability.remainingPlaces
+		}
+	};
+	return ticketType;
 }
-function getImplicitSingleTicketType(ticketTypes) {
-	return ticketTypes.length === 1 && ticketTypes[0] && canRequestTicketOption(ticketTypes[0].availability) ? ticketTypes[0] : null;
+function ticketTypeMatchesMode(ticketType, mode) {
+	const scope = ticketType.attendanceScope ?? "both";
+	return !mode || scope === "both" || scope === mode;
+}
+function getImplicitSingleTicketType(ticketTypes, purpose = "book") {
+	return ticketTypes.length === 1 && ticketTypes[0] && canRequestTicketOption(ticketTypes[0].availability, purpose) ? ticketTypes[0] : null;
 }
 function findSelectedTicketType(input) {
 	if (!input.selectedPricingOptionId) {
@@ -32786,6 +33553,27 @@ function getEligibilityFlowFlags(input) {
 		isMembershipFastTrack: input.portalAuthState === "authenticated" && hasMembership && input.ticketsCount === 1 && input.paymentMethod === "membership"
 	};
 }
+/** Prefer refreshed capacity, including a known zero; fall back while options load. */
+function getTicketSelectionRemainingPlaces(input) {
+	const availability = input.eligibility?.availability;
+	if (availability && "remainingPlaces" in availability) return availability.remainingPlaces ?? null;
+	return input.event ? getEventAvailability(selectEventCapacitySource(input.event, input.attendanceMode)).available : null;
+}
+function resolveHeldTicketPlaces(current, invitation, paymentHold) {
+	const held = invitation.kind === "ready" ? {
+		selectionId: invitation.restoration.event?.selectionId ?? current.selectionId,
+		attendanceMode: invitation.restoration.attendanceMode,
+		lines: invitation.restoration.ticketSelections
+	} : paymentHold;
+	return getHeldPlacesBySelection(current, held);
+}
+function getCurrentTicketSelection(event, attendanceMode, lines) {
+	return {
+		selectionId: event?.selectionId ?? null,
+		attendanceMode,
+		lines
+	};
+}
 
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/event-registration/registrationDraft.state.ts
@@ -35068,9 +35856,7 @@ function buildConfirmationPaymentCandidate(input) {
 		default: return assertNever$7(input);
 	}
 }
-/** Public payment evidence returns only schema-valid decisions. Legacy email
-* snapshots deliberately use the amount calculation below instead of this boundary.
-*/
+/** Persisted booking payment evidence returns only schema-valid decisions. */
 function buildConfirmationPayment(input) {
 	const payment = buildConfirmationPaymentCandidate(input);
 	if (!payment.ok) return payment;
@@ -35081,24 +35867,6 @@ function buildConfirmationPayment(input) {
 function settledOrderItemTotalCents(item) {
 	return effectiveOrderItemNetTotalCents(item) + (item.creditCents ?? 0);
 }
-/** Historical notification amounts, not a validated public payment decision.
-* Preserve HEAD's raw snapshot numbers; strict evidence validation belongs to
-* the public read boundary, not notification-plan construction (#1587).
-*/
-function calculateOrderItemsConfirmationPaymentAmounts(input) {
-	const totalCents = input.items.reduce((total, item) => total + settledOrderItemTotalCents(item), 0);
-	const amountPaidCents = input.settlement.kind === "settled_in_full" ? totalCents : input.settlement.collectedCents;
-	return {
-		amountPaidCents,
-		amountOutstandingCents: calculateOutstandingOrderAmountCents({
-			totalCents,
-			settledCents: amountPaidCents
-		})
-	};
-}
-function collectedOrderItemsConfirmationCents(items, collectedCentsByOrderItemId) {
-	return items.reduce((total, item) => total + (collectedCentsByOrderItemId[item.id] ?? 0), 0);
-}
 
 //#endregion
 //#region ../commerce/src/purchase/confirmationEmailPayment.ts
@@ -35160,56 +35928,9 @@ function toConfirmationEmailPaymentSummary(payment) {
 		default: return assertNever$7(payment);
 	}
 }
-/** Legacy notification adapter, retained unchanged in meaning until #1587. */
-function buildOrderItemsConfirmationEmailPaymentSummary(options) {
-	switch (options.orderPaymentMethod) {
-		case "stripe":
-		case "store_credit":
-		case "mixed": {
-			const amounts = calculateOrderItemsConfirmationPaymentAmounts({
-				items: options.items,
-				settlement: options.settlement
-			});
-			return {
-				kind: "monetary",
-				amountPaidCents: amounts.amountPaidCents,
-				...options.settlement.kind === "settled_in_full" ? {} : {
-					amountOutstandingCents: amounts.amountOutstandingCents,
-					dueAt: options.flexibleBalanceDueAt ?? null
-				},
-				currency: options.currency,
-				paymentMethod: options.orderPaymentMethod
-			};
-		}
-		case "pass_redemption": return { kind: "pass" };
-		case "membership_access": return { kind: "membership" };
-		case "manual": return options.flexibleBalanceDueAt ? {
-			kind: "managed_balance_due",
-			dueAt: options.flexibleBalanceDueAt
-		} : { kind: "manual_due" };
-		case "waived": return { kind: "waived" };
-		case "free": return { kind: "free" };
-		default: return assertNever$7(options.orderPaymentMethod);
-	}
-}
-function buildOrderItemConfirmationEmailPaymentSummary(options) {
-	return buildOrderItemsConfirmationEmailPaymentSummary({
-		...options,
-		items: [options.item]
-	});
-}
-function buildEventRegistrationConfirmationEmailPaymentSummary(options) {
-	return buildNonMonetaryConfirmationEmailPaymentSummary({
-		paymentMethod: options.paymentMethod,
-		passCreditsUsed: options.passCreditsUsed
-	});
-}
 function buildManualAttendeeConfirmationEmailPaymentSummary(options) {
 	return buildNonMonetaryConfirmationEmailPaymentSummary(options);
 }
-function buildBundleConfirmationEmailPaymentSummary(options) {
-	return buildNonMonetaryConfirmationEmailPaymentSummary(options);
-}
 function buildTransferredAttendeeConfirmationEmailPaymentSummary(options) {
 	switch (options.paymentMethod) {
 		case "free":
@@ -35223,34 +35944,6 @@ function buildTransferredAttendeeConfirmationEmailPaymentSummary(options) {
 	}
 	return assertNever$7(options.paymentMethod);
 }
-function buildEventSeriesRegistrationConfirmationEmailPaymentSummary(options) {
-	switch (options.paymentMethod) {
-		case "free":
-		case "membership": return buildNonMonetaryConfirmationEmailPaymentSummary({
-			paymentMethod: options.paymentMethod,
-			membershipName: options.membershipName
-		});
-		case "stripe": return buildMonetaryConfirmationEmailPaymentSummary({
-			amountPaidCents: options.amountPaidCents,
-			currency: options.currency,
-			paymentMethod: "stripe"
-		});
-	}
-	return assertNever$7(options.paymentMethod);
-}
-function buildBypassedCheckoutConfirmationEmailPaymentSummary(options) {
-	switch (options.bypassReason) {
-		case "free":
-		case "discount_free": return { kind: "free" };
-		case "store_credit": return {
-			kind: "monetary",
-			amountPaidCents: options.settledAmountCents,
-			currency: options.currency,
-			paymentMethod: "store_credit"
-		};
-	}
-	return assertNever$7(options.bypassReason);
-}
 function toConfirmationEmailTemplatePaymentFields(summary) {
 	if (!summary) {
 		return {};
@@ -35814,170 +36507,143 @@ function resolveInstalmentPlanIntroText(input) {
 
 //#endregion
 //#region ../commerce/src/purchase/orderCompletionEmailPlan.ts
-function buildEventConfirmationAction(items, options) {
-	const firstItem = items[0];
-	if (!firstItem) {
-		throw new Error("Cannot build an event confirmation without order items");
-	}
-	const settlement = options.settlement;
-	const paymentSummary = buildOrderItemsConfirmationEmailPaymentSummary({
-		orderPaymentMethod: options.orderPaymentMethod,
-		items,
-		currency: options.currency,
-		flexibleBalanceDueAt: options.flexibleBalanceDueAt,
-		settlement: settlement.kind === "settled_in_full" ? settlement : {
-			kind: "collected",
-			collectedCents: collectedOrderItemsConfirmationCents(items, settlement.collectedCentsByOrderItemId)
-		}
-	});
-	return {
-		kind: "send_event_confirmation",
-		attendeeId: firstItem.eventAttendeeId,
-		metadata: {
-			...firstItem.metadata,
-			ticketCount: items.reduce((total, item) => total + item.metadata.ticketCount, 0)
-		},
-		paymentSummary
-	};
-}
 function hasPassBundleFulfillment(metadata) {
 	return !!metadata.bundleFulfillment;
 }
 function hasMembershipBundleFulfillment(metadata) {
 	return !!metadata.bundleFulfillment;
 }
-function buildOrderCompletionEmailPlan(options) {
-	const firstItem = options.items[0];
-	if (!firstItem) {
-		return {
+const noActions = () => ({
+	actions: [],
+	warnings: []
+});
+function planEventItem(item, input) {
+	const id = item.kind === "event_ticket" ? item.eventAttendeeId : item.eventSeriesRegistrationId;
+	if (!id) return {
+		actions: [],
+		warnings: [{
+			kind: item.kind === "event_ticket" ? "missing_event_attendee_id" : "missing_event_series_registration_id",
+			orderId: item.orderId,
+			orderItemId: item.id
+		}]
+	};
+	const facts = input.bookingFacts.get(id);
+	if (!facts) return noActions();
+	if (item.kind === "event_ticket" && item.eventAttendeeId) return {
+		warnings: [],
+		actions: [{
+			kind: "send_event_confirmation",
+			facts,
+			metadata: item.metadata
+		}]
+	};
+	return {
+		warnings: [],
+		actions: [{
+			kind: "send_event_series_registration_confirmation",
+			orderId: item.orderId,
+			facts
+		}]
+	};
+}
+function planPassItem(item, input) {
+	if (!hasPassBundleFulfillment(item.metadata)) return noActions();
+	if (!item.eventAttendeeId) return {
+		actions: [],
+		warnings: [{
+			kind: "missing_event_attendee_id",
+			orderId: item.orderId,
+			orderItemId: item.id
+		}]
+	};
+	const facts = input.bookingFacts.get(item.eventAttendeeId);
+	return facts ? {
+		warnings: [],
+		actions: [{
+			kind: "send_pass_bundle_confirmation",
+			facts,
+			metadata: item.metadata
+		}]
+	} : noActions();
+}
+function planMembershipItem(item, input) {
+	if (hasMembershipBundleFulfillment(item.metadata)) {
+		if (!item.eventAttendeeId) return {
 			actions: [],
-			warnings: []
+			warnings: [{
+				kind: "missing_event_attendee_id",
+				orderId: item.orderId,
+				orderItemId: item.id
+			}]
 		};
+		const facts = input.bookingFacts.get(item.eventAttendeeId);
+		return facts ? {
+			warnings: [],
+			actions: [{
+				kind: "send_membership_bundle_confirmation",
+				facts,
+				metadata: item.metadata
+			}]
+		} : noActions();
+	}
+	if (!item.customerMembershipId) return {
+		actions: [],
+		warnings: [{
+			kind: "missing_customer_membership_id",
+			orderId: item.orderId,
+			orderItemId: item.id
+		}]
+	};
+	return {
+		warnings: [],
+		actions: [{
+			kind: "send_membership_activation",
+			customerMembershipId: item.customerMembershipId,
+			amountPaidCents: settledOrderItemTotalCents(item)
+		}]
+	};
+}
+function planItem(item, input) {
+	switch (item.kind) {
+		case "event_ticket":
+		case "event_series_registration": return planEventItem(item, input);
+		case "pass": return planPassItem(item, input);
+		case "membership": return planMembershipItem(item, input);
+		case "appointment": return item.appointmentId ? {
+			warnings: [],
+			actions: [{
+				kind: "send_appointment_confirmation",
+				appointmentId: item.appointmentId
+			}]
+		} : {
+			actions: [],
+			warnings: [{
+				kind: "missing_appointment_id",
+				orderId: item.orderId,
+				orderItemId: item.id
+			}]
+		};
+		case "product": return noActions();
 	}
-	const actions$1 = [];
-	const warnings = [];
-	const plannedEventAttendeeIds = new Set();
-	for (const item of options.items) {
-		switch (item.kind) {
-			case "event_ticket":
-				if (!item.eventAttendeeId) {
-					warnings.push({
-						kind: "missing_event_attendee_id",
-						orderItemId: item.id,
-						orderId: item.orderId
-					});
-					break;
-				}
-				if (plannedEventAttendeeIds.has(item.eventAttendeeId)) {
-					break;
-				}
-				plannedEventAttendeeIds.add(item.eventAttendeeId);
-				actions$1.push(buildEventConfirmationAction(options.items.filter((candidate) => candidate.kind === "event_ticket" && candidate.eventAttendeeId === item.eventAttendeeId), {
-					orderPaymentMethod: options.orderPaymentMethod,
-					currency: options.currency,
-					flexibleBalanceDueAt: options.flexibleBalanceDueAt ?? null,
-					settlement: options.settlement
-				}));
-				break;
-			case "pass":
-				if (hasPassBundleFulfillment(item.metadata)) {
-					if (!item.eventAttendeeId) {
-						warnings.push({
-							kind: "missing_event_attendee_id",
-							orderItemId: item.id,
-							orderId: item.orderId
-						});
-						break;
-					}
-					actions$1.push({
-						kind: "send_pass_bundle_confirmation",
-						attendeeId: item.eventAttendeeId,
-						metadata: item.metadata
-					});
-				}
-				break;
-			case "event_series_registration":
-				if (!item.eventSeriesRegistrationId) {
-					warnings.push({
-						kind: "missing_event_series_registration_id",
-						orderItemId: item.id,
-						orderId: item.orderId
-					});
-					break;
-				}
-				actions$1.push({
-					kind: "send_event_series_registration_confirmation",
-					orderId: item.orderId,
-					registrationId: item.eventSeriesRegistrationId,
-					paymentSummary: buildOrderItemConfirmationEmailPaymentSummary({
-						orderPaymentMethod: options.orderPaymentMethod,
-						item,
-						currency: options.currency,
-						flexibleBalanceDueAt: options.flexibleBalanceDueAt ?? null,
-						settlement: options.settlement.kind === "settled_in_full" ? options.settlement : {
-							kind: "collected",
-							collectedCents: options.settlement.collectedCentsByOrderItemId[item.id] ?? 0
-						}
-					})
-				});
-				break;
-			case "appointment":
-				if (!item.appointmentId) {
-					warnings.push({
-						kind: "missing_appointment_id",
-						orderItemId: item.id,
-						orderId: item.orderId
-					});
-					break;
-				}
-				actions$1.push({
-					kind: "send_appointment_confirmation",
-					appointmentId: item.appointmentId
-				});
-				break;
-			case "membership":
-				if (hasMembershipBundleFulfillment(item.metadata)) {
-					if (!item.eventAttendeeId) {
-						warnings.push({
-							kind: "missing_event_attendee_id",
-							orderItemId: item.id,
-							orderId: item.orderId
-						});
-						break;
-					}
-					actions$1.push({
-						kind: "send_membership_bundle_confirmation",
-						attendeeId: item.eventAttendeeId,
-						metadata: item.metadata
-					});
-					break;
-				}
-				if (!item.customerMembershipId) {
-					warnings.push({
-						kind: "missing_customer_membership_id",
-						orderItemId: item.id,
-						orderId: item.orderId
-					});
-					break;
-				}
-				actions$1.push({
-					kind: "send_membership_activation",
-					customerMembershipId: item.customerMembershipId,
-					amountPaidCents: settledOrderItemTotalCents(item)
-				});
-				break;
-			case "product": break;
-		}
-	}
-	if (options.items.some((item) => item.kind === "product" || item.kind === "pass")) {
-		actions$1.unshift({
-			kind: "send_order_confirmation",
-			orderId: firstItem.orderId
-		});
-	}
+}
+function bookingGroupId(item) {
+	return item.eventAttendeeId ?? item.eventSeriesRegistrationId ?? null;
+}
+/** Complete booking facts are already decided; purchase receipts remain separate. */
+function buildOrderCompletionEmailPlan(input) {
+	const first = input.items[0];
+	if (!first) return noActions();
+	const plans = input.items.filter((item, index) => {
+		const id = bookingGroupId(item);
+		return id === null || !input.items.slice(0, index).some((previous) => bookingGroupId(previous) === id);
+	}).map((item) => planItem(item, input));
+	const receipt = input.items.some((item) => item.kind === "product" || item.kind === "pass") ? [{
+		kind: "send_order_confirmation",
+		orderId: first.orderId
+	}] : [];
 	return {
-		actions: actions$1,
-		warnings
+		actions: [...receipt, ...plans.flatMap((plan) => plan.actions)],
+		warnings: plans.flatMap((plan) => plan.warnings)
 	};
 }
 
@@ -38389,6 +39055,9 @@ function getStepLabel(step) {
 function visitorHoldsOwnPlace(input) {
 	return input.hasWaitlistClaim || input.retryingHeldPlace;
 }
+function getTicketSelectionPurpose(admission) {
+	return admission.kind === "waitlist" ? "waitlist" : "book";
+}
 function resolveRegistrationAdmission(input) {
 	if (input.holdsOwnPlace) return { kind: "resume" };
 	if (input.eligibilityLoading) return { kind: "checking" };
@@ -40939,6 +41608,15 @@ const eventRegistrationManifest = createBlockManifest({
 		], { gap: "lg" })
 	})]
 });
+const registrationEventScopeParams = {
+	detailAdmission: { $bind: { from: "$root.subject.detailAdmission" } },
+	seriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
+	seriesIds: { $bind: {
+		from: "$root.subject.catalogueEventSeriesIds",
+		transforms: [{ id: "value.csv" }]
+	} },
+	runSeriesId: { $bind: { from: "$root.entrySubrouteContext.run.seriesId" } }
+};
 const eventRegistrationBlockDefinition = {
 	manifest: eventRegistrationManifest,
 	runtime: eventRegistrationBlockRuntime,
@@ -40965,12 +41643,7 @@ const eventRegistrationBlockDefinition = {
 					fallback: "published"
 				} },
 				readProfile: "registration",
-				seriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
-				seriesIds: { $bind: {
-					from: "$root.subject.catalogueEventSeriesIds",
-					transforms: [{ id: "value.csv" }]
-				} },
-				runSeriesId: { $bind: { from: "$root.entrySubrouteContext.run.seriesId" } },
+				...registrationEventScopeParams,
 				includeOccurrenceId: { $bind: { from: "$root.occurrenceContext.id" } }
 			},
 			mode: "server"
@@ -40990,12 +41663,7 @@ const eventRegistrationBlockDefinition = {
 					fallback: "published"
 				} },
 				readProfile: "registration",
-				seriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
-				seriesIds: { $bind: {
-					from: "$root.subject.catalogueEventSeriesIds",
-					transforms: [{ id: "value.csv" }]
-				} },
-				runSeriesId: { $bind: { from: "$root.entrySubrouteContext.run.seriesId" } }
+				...registrationEventScopeParams
 			},
 			mode: "server"
 		},
@@ -41472,6 +42140,7 @@ const eventDetailsBlockDefinition = {
 			} },
 			limit: "100",
 			readProfile: "details",
+			detailAdmission: { $bind: { from: "$root.subject.detailAdmission" } },
 			seriesId: { $bind: { from: "$root.subject.eventSeriesId" } },
 			seriesIds: { $bind: {
 				from: "$root.subject.catalogueEventSeriesIds",
@@ -47422,6 +48091,7 @@ const recurringScheduleLayout = styledSection({
 				fallback: "secondary"
 			} }
 		}, [text({}, bind("content.seeAllLabel"))], when("content.seeAllUrl"))]), el("recurring-schedule", {
+			dateContext: { $bind: { from: "$root.dateContext" } },
 			schedule: { $bind: { from: "data.schedule" } },
 			buttonText: { $bind: {
 				from: "content.buttonText",
@@ -50378,7 +51048,12 @@ const contentEntrySchema = z.object({
 	id: z.string().nullable().optional(),
 	slug: z.string().nullable().optional()
 }).nullable();
+const shopDateContextSchema = z.object({
+	locale: z.string(),
+	timeZone: z.string().transform(resolveBookingBusinessTimeZone)
+});
 const shopSourceSchema = z.object({
+	dateContext: shopDateContextSchema.optional(),
 	...cardListPresentationSchemaShape,
 	featured: z.string().nullable().optional(),
 	className: z.string().nullable().optional(),
@@ -50543,6 +51218,7 @@ const checkoutDisplaySchema = z.object({
 	submitButtonText: z.string()
 });
 const passesMembershipsHydrationSchema = z.object({
+	dateContext: shopDateContextSchema,
 	presentation: z.object(cardListPresentationSchemaShape).optional(),
 	featured: z.string().optional(),
 	memberships: z.array(publicMembershipProductSchema),
@@ -50623,6 +51299,7 @@ const shopBlockRuntime = defineProgressiveBlockRuntime({
 		const passPurchaseMode = source.passPurchaseMode ?? "add_to_cart";
 		const subscribeButtonText = source.subscribeButtonText ?? "Subscribe";
 		const products = shopDisplayedProducts(source);
+		const dateContext = source.dateContext ?? resolveDateRuntimeContext(undefined);
 		return {
 			display: buildPassesMembershipsDisplay({
 				cardList: source.lookSlots !== undefined,
@@ -50643,6 +51320,10 @@ const shopBlockRuntime = defineProgressiveBlockRuntime({
 			hydration: {
 				...source.lookSlots ? { presentation: shopCardListPresentation(source) } : {},
 				...shopFeaturedProduct(source, products),
+				dateContext: {
+					locale: dateContext.locale,
+					timeZone: dateContext.timeZone
+				},
 				memberships: products.memberships,
 				passPurchaseMode,
 				buttonVariant: source.buttonVariant ?? "primary",
@@ -51167,6 +51848,7 @@ const shopManifest = createBlockManifest({
 			featured: { $bind: { from: "content.featured" } },
 			readAuthority: { $bind: { from: "$root.readAuthority" } },
 			siteTerms: { $bind: { from: "$root.siteTerms" } },
+			dateContext: { $bind: { from: "$root.dateContext" } },
 			demoEmailSuppressed: { $bind: {
 				from: "$root.demoEmailSuppressed",
 				fallback: false
@@ -53062,6 +53744,7 @@ function describeUnresolvedLocationMapLocation(resolvedLocation) {
 	}
 }
 function normalizeLocationMapProps(input) {
+	const parsedHours = parseWeeklyOpeningHours(input.openingHours);
 	const resolvedLocation = resolveLocationMapLocation(input);
 	const locationValue = resolvedLocation.kind === "unresolved" ? null : resolvedLocation.locationValue;
 	const directionsLabel = normalizeLocationAddressText(input.directionsLabel) ?? LOCATION_MAP_DEFAULTS.directionsLabel;
@@ -53073,6 +53756,8 @@ function normalizeLocationMapProps(input) {
 		location: toLocationCoordinates(locationValue),
 		zoom: Math.min(LOCATION_MAP_LIMITS.zoom.max, Math.max(LOCATION_MAP_LIMITS.zoom.min, Math.round(normalizeNumber(input.zoom, LOCATION_MAP_DEFAULTS.zoom)))),
 		heightPx: Math.min(LOCATION_MAP_LIMITS.heightPx.max, Math.max(LOCATION_MAP_LIMITS.heightPx.min, Math.round(normalizeNumber(input.heightPx, LOCATION_MAP_DEFAULTS.heightPx)))),
+		openingHours: parsedHours.ok ? parsedHours.value : null,
+		showOpeningHours: normalizeBoolean$1(input.showOpeningHours, true),
 		showAddressText: normalizeBoolean$1(input.showAddressText, LOCATION_MAP_DEFAULTS.showAddressText),
 		showDirections: normalizeBoolean$1(input.showDirections, LOCATION_MAP_DEFAULTS.showDirections),
 		directionsLabel,
@@ -53085,6 +53770,8 @@ function toLocationMapHydrationProps(input) {
 		location: normalized.locationValue,
 		zoom: normalized.zoom,
 		heightPx: normalized.heightPx,
+		openingHours: normalized.openingHours,
+		showOpeningHours: normalized.showOpeningHours,
 		showAddressText: normalized.showAddressText,
 		showDirections: normalized.showDirections,
 		directionsLabel: normalized.directionsLabel,
@@ -53122,6 +53809,7 @@ function normalizeLocationMapContent(content) {
 		heading: typeof record.heading === "string" ? record.heading : undefined,
 		locationSource,
 		...authoredLocationMapSourceFields(locationSource, venueId, normalized.locationValue),
+		showOpeningHours: record.showOpeningHours !== false,
 		showAddressText: normalized.showAddressText,
 		showDirections: normalized.showDirections,
 		directionsLabel: normalized.directionsLabel,
@@ -53255,6 +53943,13 @@ const locationMapManifest = createBlockManifest({
 				}
 			] }
 		}),
+		parseFieldDefinition({
+			id: "showOpeningHours",
+			type: "boolean",
+			label: "Show opening hours",
+			defaultValue: true,
+			ui: { intent: "display" }
+		}),
 		parseFieldDefinition({
 			id: "showAddressText",
 			type: "boolean",
@@ -53316,6 +54011,14 @@ const locationMapManifest = createBlockManifest({
 		baseClass: "",
 		spacing: "comfortable",
 		children: sectionContainer([text({ as: "h2" }, bind("content.heading"), when("content.heading")), el("location-map", {
+			openingHours: { $bind: {
+				from: "$root.openingHours",
+				fallback: null
+			} },
+			showOpeningHours: { $bind: {
+				from: "content.showOpeningHours",
+				fallback: true
+			} },
 			location: { $bind: {
 				from: "content.location",
 				fallback: null
@@ -53368,6 +54071,7 @@ const locationMapBlockDefinition = {
 			"venueId",
 			"location",
 			"showAddressText",
+			"showOpeningHours",
 			"showDirections",
 			"directionsLabel",
 			"zoom",
@@ -58504,6 +59208,7 @@ function validateAppointmentBookingFormSource(input) {
 }
 function normalizeAppointmentBookingServices(input) {
 	return input.services.map((service) => ({
+		...service.image === undefined ? {} : { image: service.image },
 		id: service.id,
 		siteId: input.siteId,
 		title: service.title,
@@ -58598,6 +59303,7 @@ const blockBookingPaymentTermsAvailabilitySchema = z.union([z.object({
 	reason: z.literal("online_payment_configured_before_launch")
 })]);
 const bookingServiceSchema = z.object({
+	image: runtimeMediaSchema.nullable().optional(),
 	location: z.object({ mode: z.enum([
 		"online",
 		"in_person",
@@ -59103,7 +59809,7 @@ function resolveEventDetailsPresentation(input) {
 //#region ../blocks/src/system/blocks/offerings-preview/scheduleSummary.ts
 function deriveEventScheduleSummary(event) {
 	const occurrence = occurrenceFromEvent(event);
-	return localDayNumber(occurrence.endsAt, occurrence.timeZone) > localDayNumber(occurrence.startsAt, occurrence.timeZone) ? {
+	return compareLocalScheduleDates(getLocalScheduleDate(new Date(occurrence.endsAt), resolveBookingBusinessTimeZone(occurrence.timeZone)), getLocalScheduleDate(new Date(occurrence.startsAt), resolveBookingBusinessTimeZone(occurrence.timeZone))) > 0 ? {
 		kind: "multi-day-span",
 		occurrence
 	} : {
@@ -59111,23 +59817,18 @@ function deriveEventScheduleSummary(event) {
 		occurrence
 	};
 }
-function derivePreviewRunSchedule(runSessions) {
-	const sessions = orderedLiveRunSessions(runSessions).filter(isValidOccurrence);
+function derivePreviewRunSchedule(event) {
+	const sessions = orderedLiveRunSessions(event.run.sessions).filter(isValidOccurrence);
 	const first = sessions[0];
 	const last = sessions[sessions.length - 1];
 	if (!first || !last) return { kind: "no-live-sessions" };
-	const recurrence = sessions.length > 1 ? deriveFixedRecurrence(sessions) : null;
-	const summary = sessions.length === 1 ? deriveEventScheduleSummary(first) : recurrence ? {
-		kind: "fixed-recurring-run",
+	const authoredSummary = formatBookingSchedulePresentation("representative" in event ? event.representative : event);
+	const summary = !authoredSummary && sessions.length === 1 ? deriveEventScheduleSummary(first) : {
+		kind: "scheduled-run",
 		first,
 		last,
 		sessionCount: sessions.length,
-		recurrenceLabel: recurrence
-	} : {
-		kind: "irregular-multi-session-run",
-		first,
-		last,
-		sessionCount: sessions.length
+		authoredSummary
 	};
 	return {
 		kind: "scheduled",
@@ -59143,62 +59844,9 @@ function occurrenceFromEvent(event) {
 		timeZone: event.timeZone
 	};
 }
-function deriveFixedRecurrence(sessions) {
-	const [first, second] = sessions;
-	if (!first || !second) return null;
-	if (!sessions.every((session) => sameLocalTime(first, session))) return null;
-	const intervalDays = localDayNumber(second.startsAt, second.timeZone) - localDayNumber(first.startsAt, first.timeZone);
-	if (intervalDays <= 0) return null;
-	for (let index = 2; index < sessions.length; index += 1) {
-		const previous = sessions[index - 1];
-		const current = sessions[index];
-		if (!previous || !current) return null;
-		const currentInterval = localDayNumber(current.startsAt, current.timeZone) - localDayNumber(previous.startsAt, previous.timeZone);
-		if (currentInterval !== intervalDays) return null;
-	}
-	if (intervalDays === 1) return "Every day";
-	const weekday = localDateParts(first.startsAt, first.timeZone).weekday;
-	if (intervalDays === 7) return `Every ${weekday}`;
-	if (intervalDays % 7 === 0) {
-		return `Every ${intervalDays / 7} weeks on ${weekday}`;
-	}
-	return `Every ${intervalDays} days`;
-}
-function sameLocalTime(reference, candidate) {
-	const referenceStart = localDateParts(reference.startsAt, reference.timeZone);
-	const candidateStart = localDateParts(candidate.startsAt, candidate.timeZone);
-	const referenceEnd = localDateParts(reference.endsAt, reference.timeZone);
-	const candidateEnd = localDateParts(candidate.endsAt, candidate.timeZone);
-	return referenceStart.hour === candidateStart.hour && referenceStart.minute === candidateStart.minute && referenceEnd.hour === candidateEnd.hour && referenceEnd.minute === candidateEnd.minute;
-}
 function isValidOccurrence(value) {
 	return Number.isFinite(Date.parse(value.startsAt)) && Number.isFinite(Date.parse(value.endsAt));
 }
-function localDayNumber(isoTimestamp, timeZone) {
-	const parts = localDateParts(isoTimestamp, timeZone);
-	return Math.floor(Date.UTC(parts.year, parts.month - 1, parts.day) / 864e5);
-}
-function localDateParts(isoTimestamp, timeZone) {
-	const parts = new Intl.DateTimeFormat("en-GB", {
-		timeZone,
-		year: "numeric",
-		month: "numeric",
-		day: "numeric",
-		hour: "2-digit",
-		minute: "2-digit",
-		hourCycle: "h23",
-		weekday: "long"
-	}).formatToParts(new Date(isoTimestamp));
-	const value = (type) => parts.find((part) => part.type === type)?.value ?? "";
-	return {
-		year: Number(value("year")),
-		month: Number(value("month")),
-		day: Number(value("day")),
-		hour: Number(value("hour")),
-		minute: Number(value("minute")),
-		weekday: value("weekday")
-	};
-}
 
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/events/shared/eventCardListContent.ts
@@ -59253,7 +59901,7 @@ function offeringLeadDate(event, startMs) {
 	};
 }
 function offeringSchedule(event, now) {
-	const run = event.bookingScope === "whole_series" ? derivePreviewRunSchedule(event.run.sessions) : null;
+	const run = event.bookingScope === "whole_series" ? derivePreviewRunSchedule(event) : null;
 	if (run?.kind === "no-live-sessions") return {
 		numeral: null,
 		schedule: null
@@ -59284,7 +59932,7 @@ function scheduleLine(summary, event, now) {
 		date: "short",
 		year: now ? year(value) : "omit"
 	});
-	const dates = (startsAt, endsAt) => formatDateRange({
+	const dates = (startsAt, endsAt, order = "chronological") => formatDateRange({
 		kind: "civil",
 		value: getLocalScheduleDate(new Date(startsAt), context.timeZone)
 	}, {
@@ -59292,6 +59940,7 @@ function scheduleLine(summary, event, now) {
 		value: getLocalScheduleDate(new Date(endsAt), resolveBookingBusinessTimeZone(last.timeZone))
 	}, context, {
 		date: "short",
+		order,
 		year: now && year(startsAt) === "omit" && year(endsAt, resolveBookingBusinessTimeZone(last.timeZone)) === "omit" ? "omit" : now ? "numeric" : "omit"
 	});
 	switch (summary.kind) {
@@ -59305,8 +59954,7 @@ function scheduleLine(summary, event, now) {
 			zone
 		}) : date(summary.occurrence.startsAt);
 		case "multi-day-span": return dates(summary.occurrence.startsAt, summary.occurrence.endsAt);
-		case "fixed-recurring-run": return `${dates(summary.first.startsAt, summary.last.startsAt)} · ${summary.recurrenceLabel}`;
-		case "irregular-multi-session-run": return `${dates(summary.first.startsAt, summary.last.startsAt)} · ${summary.sessionCount} dates`;
+		case "scheduled-run": return `${dates(summary.first.startsAt, summary.last.startsAt, "session")} · ${summary.authoredSummary?.text ?? `${summary.sessionCount} dates`}`;
 	}
 }
 function offeringAvailability(event) {
@@ -59945,16 +60593,44 @@ var event_details_server_default = EventDetailsSSR;
 
 //#endregion
 //#region ../blocks/src/system/runtime/nodes/location-map.view.tsx
-function LocationMapView({ addressText, location, zoom, heightPx, showAddressText, showDirections, directionsLabel, unresolvedMessage, renderMap }) {
-	const directionsUrl = buildGoogleMapsDirectionsUrl({
+function OpeningHoursTable({ hours: hours$1 }) {
+	if (!hours$1) return null;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("table", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("caption", { children: "Opening hours" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("tbody", { children: formatOpeningHoursRows(hours$1).map((row$1) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("tr", {
+		"data-closed": row$1.kind === "closed" ? true : undefined,
+		children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("th", {
+			scope: "row",
+			children: row$1.label
+		}), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("td", { children: row$1.hours })]
+	}, row$1.label)) })] }), hours$1.note ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { children: hours$1.note }) : null] });
+}
+function LocationMapDirections({ url, label }) {
+	return url ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ThemedButtonLink, {
+		href: url,
+		target: "_blank",
+		rel: "noreferrer",
+		variant: "ghost",
+		size: "sm",
+		extraClassName: "rb-w-fit",
+		label
+	}) : null;
+}
+function LocationMapView(props$1) {
+	const { addressText, location, renderMap, zoom, heightPx, showAddressText, directionsLabel } = props$1;
+	const directionsUrl = props$1.showDirections ? buildGoogleMapsDirectionsUrl({
 		addressText,
 		location
-	});
-	if (!location && !addressText && !directionsUrl) {
+	}) : null;
+	const hours$1 = props$1.showOpeningHours === false ? null : props$1.openingHours ?? null;
+	if (![
+		location,
+		addressText,
+		directionsUrl,
+		hours$1
+	].some(Boolean)) {
 		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
 			className: "rb-caption",
 			style: textColorStyle("mutedText"),
-			children: unresolvedMessage ?? "Location details coming soon."
+			children: props$1.unresolvedMessage ?? "Location details coming soon."
 		});
 	}
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", {
@@ -59972,15 +60648,11 @@ function LocationMapView({ addressText, location, zoom, heightPx, showAddressTex
 				style: textColorStyle("mutedText"),
 				children: addressText
 			}) : null,
-			showDirections && directionsUrl ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ThemedButtonLink, {
-				href: directionsUrl,
-				target: "_blank",
-				rel: "noreferrer",
-				variant: "ghost",
-				size: "sm",
-				extraClassName: "rb-w-fit",
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(OpeningHoursTable, { hours: hours$1 }),
+			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(LocationMapDirections, {
+				url: directionsUrl,
 				label: directionsLabel
-			}) : null
+			})
 		]
 	});
 }
@@ -59997,14 +60669,7 @@ function LocationMapSSR(props$1) {
 		children: [
 			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(IslandPropsScript, { value: hydrationProps }),
 			/* @__PURE__ */ (0, import_jsx_runtime.jsx)(LocationMapView, {
-				addressText: normalized.addressText,
-				location: normalized.location,
-				zoom: normalized.zoom,
-				heightPx: normalized.heightPx,
-				showAddressText: normalized.showAddressText,
-				showDirections: normalized.showDirections,
-				directionsLabel: normalized.directionsLabel,
-				unresolvedMessage: normalized.unresolvedMessage,
+				...normalized,
 				renderMap: ({ addressText, className, height }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
 					className,
 					style: {
@@ -60646,7 +61311,7 @@ function FeaturedOfferingSummary({ item }) {
 			children: [
 				details.recurrence ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Repeats" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { children: details.recurrence })] }) : null,
 				details.sessionCount ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Sessions" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { children: details.sessionCount })] }) : null,
-				/* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Time" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { children: details.timeRange })] }),
+				details.timeRange ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Time" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { children: details.timeRange })] }) : null,
 				details.venue ? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, import_jsx_runtime.jsx)("dt", { children: "Venue" }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)("dd", { children: details.venue })] }) : null
 			]
 		})]
@@ -60660,7 +61325,7 @@ function featuredSummaryDetails(item) {
 			deliveryMode: item.event.deliveryMode
 		});
 		case "run": {
-			const schedule = derivePreviewRunSchedule(item.run.run.sessions);
+			const schedule = derivePreviewRunSchedule(item.run);
 			return schedule.kind === "scheduled" ? formatFeaturedSummary(schedule.summary, {
 				venue: item.run.representative.venue?.name ?? null,
 				siteTimeZone: item.run.representative.siteTimeZone,
@@ -60674,33 +61339,33 @@ function formatFeaturedSummary(summary, place) {
 	switch (summary.kind) {
 		case "single-occurrence": return detailsFromOccurrences({
 			first: summary.occurrence,
-			last: null,
+			end: null,
 			place
 		});
 		case "multi-day-span": return detailsFromOccurrences({
 			first: summary.occurrence,
-			last: summary.occurrence,
-			place,
-			spanUsesEndDate: true
-		});
-		case "fixed-recurring-run": return detailsFromOccurrences({
-			first: summary.first,
-			last: summary.last,
-			place,
-			recurrence: summary.recurrenceLabel
+			end: {
+				dateTime: summary.occurrence.endsAt,
+				timeZone: summary.occurrence.timeZone
+			},
+			place
 		});
-		case "irregular-multi-session-run": return detailsFromOccurrences({
+		case "scheduled-run": return detailsFromOccurrences({
 			first: summary.first,
-			last: summary.last,
+			end: {
+				dateTime: summary.last.startsAt,
+				timeZone: summary.last.timeZone
+			},
 			place,
-			sessionCount: `${summary.sessionCount} dates`
+			recurrence: summary.authoredSummary ?? undefined,
+			sessionCount: `${summary.sessionCount} date${summary.sessionCount === 1 ? "" : "s"}`
 		});
 		default: return assertNever(summary, "Unhandled offerings preview schedule summary");
 	}
 }
 function detailsFromOccurrences(input) {
-	const { first, last, place } = input;
-	const endDateTime = input.spanUsesEndDate ? first.endsAt : last?.startsAt ?? first.startsAt;
+	const { first, end, place } = input;
+	const endDateTime = end?.dateTime ?? first.startsAt;
 	const options = eventDateOptions({
 		timeZone: first.timeZone,
 		siteTimeZone: place.siteTimeZone,
@@ -60710,13 +61375,15 @@ function detailsFromOccurrences(input) {
 		timeZone,
 		locale: options.locale
 	});
+	const startDate = summaryDate(first.startsAt, first.timeZone);
+	const endDate = end ? summaryDate(end.dateTime, end.timeZone) : null;
 	return {
-		startDate: summaryDate(first.startsAt, first.timeZone),
+		startDate,
 		startDateTime: first.startsAt,
-		endDate: last ? summaryDate(endDateTime, last.timeZone) : null,
+		endDate: endDate === startDate ? null : endDate,
 		endDateTime,
-		timeRange: formatEventTimeRange(first, options),
-		recurrence: input.recurrence ?? null,
+		timeRange: input.recurrence?.clock ? null : formatEventTimeRange(first, options),
+		recurrence: input.recurrence?.text ?? null,
 		sessionCount: input.sessionCount ?? null,
 		venue: place.venue
 	};
@@ -60766,8 +61433,13 @@ function renderSingleOfferingCard(item, options) {
 		}, item.run.eventSeriesId);
 	}
 }
+/** The authored clock replaces live time only when it was successfully formatted. */
+function formatRunScheduleTime(schedule, options) {
+	const authored = schedule.summary.kind === "scheduled-run" ? schedule.summary.authoredSummary : null;
+	return [authored?.text, authored?.clock ? null : formatEventTimeRange(schedule.firstSession, options)].filter(Boolean).join(" · ");
+}
 function WholeSeriesRunCompactRow({ group, path: path$3, now }) {
-	const schedule = derivePreviewRunSchedule(group.run.sessions);
+	const schedule = derivePreviewRunSchedule(group);
 	if (schedule.kind === "no-live-sessions") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RunWithoutLiveDates, {
 		group,
 		path: path$3
@@ -60779,7 +61451,7 @@ function WholeSeriesRunCompactRow({ group, path: path$3, now }) {
 		deliveryMode: group.representative.deliveryMode
 	});
 	const dateRail = formatEventCompactDateRail(firstSession.startsAt, options);
-	const timeRange = formatEventTimeRange(firstSession, options);
+	const timeRange = formatRunScheduleTime(schedule, options);
 	const price$1 = formatEventPriceDisplay(group.representative.pricing);
 	const statusLabel = resolveWholeSeriesBookingPhase(group.run, now).kind === "open" ? null : "Registration closed";
 	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("article", {
@@ -60853,7 +61525,7 @@ function WholeSeriesRunCompactRow({ group, path: path$3, now }) {
 	});
 }
 function WholeSeriesRunFeatureCard({ group, now, path: path$3, buttonVariant, buttonText }) {
-	const schedule = derivePreviewRunSchedule(group.run.sessions);
+	const schedule = derivePreviewRunSchedule(group);
 	if (schedule.kind === "no-live-sessions") return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RunWithoutLiveDates, {
 		group,
 		path: path$3
@@ -60865,7 +61537,7 @@ function WholeSeriesRunFeatureCard({ group, now, path: path$3, buttonVariant, bu
 		deliveryMode: group.representative.deliveryMode
 	});
 	const formattedDate = formatEventCompactDateRail(firstSession.startsAt, options).label;
-	const timeRange = formatEventTimeRange(firstSession, options);
+	const timeRange = formatRunScheduleTime(schedule, options);
 	const price$1 = formatEventPriceDisplay(group.representative.pricing);
 	const statusLabel = resolveWholeSeriesBookingPhase(group.run, now).kind === "open" ? null : "Registration closed";
 	const description = group.representative.description;
@@ -61197,7 +61869,7 @@ function bookingActionContent(input) {
 		default: return assertNever(input.booking);
 	}
 }
-function RecurringSchedule({ schedule, buttonText = "Book", buttonVariant = "primary", showVenue = true, emptyMessage = "Regular schedule details will be added shortly." }) {
+function RecurringSchedule({ dateContext = resolveDateRuntimeContext(undefined), schedule, buttonText = "Book", buttonVariant = "primary", showVenue = true, emptyMessage = "Regular schedule details will be added shortly." }) {
 	const projection = schedule ?? {
 		items: [],
 		diagnostics: []
@@ -61209,8 +61881,28 @@ function RecurringSchedule({ schedule, buttonText = "Book", buttonVariant = "pri
 			children: emptyMessage
 		});
 	}
-	const renderRow = (item) => {
-		const rowContent = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
+		className: "recurring-schedule",
+		"data-diagnostic-count": projection.diagnostics.length,
+		role: "list",
+		children: projection.items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RecurringScheduleRow, {
+			item,
+			locale: dateContext.locale,
+			buttonText: buttonText ?? "Book",
+			buttonVariant: buttonVariant ?? "primary",
+			showVenue: showVenue ?? true
+		}, item.seriesId))
+	});
+}
+function RecurringScheduleRow({ item, locale, buttonText, buttonVariant, showVenue }) {
+	const startLabel = formatEventClockLabel(item.cadence.startTime, locale);
+	const endLabel = formatEventClockLabel(item.cadence.endTime, locale);
+	const description = `${item.title}, ${item.cadence.weekday} at ${startLabel}`;
+	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("article", {
+		className: "recurring-schedule-row",
+		role: "listitem",
+		"aria-label": description,
+		children: [
 			/* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", {
 				className: "recurring-schedule-day",
 				children: item.cadence.weekday
@@ -61220,7 +61912,7 @@ function RecurringSchedule({ schedule, buttonText = "Book", buttonVariant = "pri
 				children: [
 					/* @__PURE__ */ (0, import_jsx_runtime.jsx)("time", {
 						dateTime: item.cadence.startTime,
-						children: item.cadence.startTime
+						children: startLabel
 					}),
 					/* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", {
 						"aria-hidden": "true",
@@ -61228,7 +61920,7 @@ function RecurringSchedule({ schedule, buttonText = "Book", buttonVariant = "pri
 					}),
 					/* @__PURE__ */ (0, import_jsx_runtime.jsx)("time", {
 						dateTime: item.cadence.endTime,
-						children: item.cadence.endTime
+						children: endLabel
 					})
 				]
 			}),
@@ -61246,24 +61938,12 @@ function RecurringSchedule({ schedule, buttonText = "Book", buttonVariant = "pri
 				className: "recurring-schedule-action",
 				children: bookingActionContent({
 					booking: item.booking,
-					buttonVariant: buttonVariant ?? "primary",
-					buttonText: buttonText ?? "Book",
-					accessibleName: `${buttonText ?? "Book"} ${item.title}, ${item.cadence.weekday} at ${item.cadence.startTime}`
+					buttonVariant,
+					buttonText,
+					accessibleName: `${buttonText} ${description}`
 				})
 			})
-		] });
-		return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("article", {
-			className: "recurring-schedule-row",
-			role: "listitem",
-			"aria-label": `${item.title}, ${item.cadence.weekday} at ${item.cadence.startTime}`,
-			children: rowContent
-		});
-	};
-	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", {
-		className: "recurring-schedule",
-		"data-diagnostic-count": projection.diagnostics.length,
-		role: "list",
-		children: projection.items.map((item) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Fragment, { children: renderRow(item) }, item.seriesId))
+		]
 	});
 }
 
@@ -67189,7 +67869,8 @@ function arrangementContentFacts(content) {
 			photo: photoCount > 0,
 			facts: Array.isArray(content.facts) && content.facts.length > 0,
 			featured,
-			outcome: typeof content.outcome === "string" && content.outcome.length > 0
+			outcome: typeof content.outcome === "string" && content.outcome.length > 0,
+			figure: typeof content.figure === "string" && content.figure.trim().length > 0
 		}
 	};
 }
@@ -67349,7 +68030,7 @@ function resolveArrangementRoleSurfaces(look, runtime, background) {
 }
 /** The arrangement key is resolved once by planBlock, including pinned Looks. */
 function heroPhotoGround(entry) {
-	return entry.kind === "renderable" && entry.block.kind === "block.hero" ? { paintsGround: entry.effectiveArrangementKey === "classic" } : undefined;
+	return entry.kind === "renderable" && entry.block.kind === "block.hero" ? { paintsGround: heroPhotoPaintsGround(entry.effectiveArrangementKey ?? undefined) } : undefined;
 }
 /** Header consumers receive the opening that the public render plan actually admits. */
 function resolvePageOpeningSection(page, options = {}) {
@@ -68470,7 +69151,7 @@ function compilePagePushCommands(input) {
 	});
 }
 function pageCommandRouting(diff) {
-	const changedPages = diff.pages.filter((pageDiff) => pageDiff.type !== "unchanged" || Boolean(pageDiff.statusChange));
+	const changedPages = diff.pages.filter(hasPageOperations);
 	if (changedPages.length === 0) return { kind: "no_page_changes" };
 	return { kind: "command_backed" };
 }
@@ -68562,7 +69243,7 @@ function pageCommandReportToSyncResult(report) {
 	});
 }
 function pageCommandsForDiff(input) {
-	if (input.pageDiff.type === "unchanged" && !input.pageDiff.statusChange) {
+	if (!hasPageOperations(input.pageDiff)) {
 		return ok(emptyPageCommandCompileFragment());
 	}
 	if (!input.localPage) {
@@ -68585,10 +69266,7 @@ function pageCommandsForDiff(input) {
 			input: {
 				identifier: localPageIdentifier,
 				slug: localPageIdentifier,
-				title: input.localPage.title,
-				path: input.localPage.path,
-				...input.localPage.seoTitle ? { seoTitle: input.localPage.seoTitle } : {},
-				...input.localPage.seoDescription ? { seoDescription: input.localPage.seoDescription } : {},
+				...pageMetadataForUpsert(input.localPage),
 				...input.localPage.status ? { status: input.localPage.status } : {}
 			}
 		};
@@ -78049,7 +78727,7 @@ async function loadConfig(configPath, output) {
 		return { errorMessage: "No config path provided." };
 	}
 	try {
-		const { loadConfigFile: loadConfigFile$1 } = await import("../load-config-Kg45qY-N.mjs");
+		const { loadConfigFile: loadConfigFile$1 } = await import("../load-config-JWz__Dkx.mjs");
 		const rawConfig = await loadConfigFile$1(configPath);
 		const parsed = riverbankSiteConfigSchema.safeParse(rawConfig);
 		if (!parsed.success) {
@@ -80616,15 +81294,13 @@ function occurrenceCapacityFromOptions(options) {
 	return options.inheritCapacity ? { kind: "inherit" } : undefined;
 }
 function formatOccurrenceLocal(iso, timeZone) {
-	return new Intl.DateTimeFormat("en-GB", {
-		timeZone,
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit",
-		hour: "2-digit",
-		minute: "2-digit",
-		hourCycle: "h23"
-	}).format(new Date(iso));
+	return formatDateTime(toUtcIsoDateTimeString(iso), {
+		locale: "en-GB",
+		timeZone: resolveBookingTimeZoneId(timeZone)
+	}, {
+		date: "short",
+		zone: "omit"
+	});
 }
 function formatDeletionEligibility(occurrence) {
 	switch (occurrence.deletionEligibility.kind) {