@riverbankcms/sdk 0.144.0 → 0.146.0

package/dist/_dts/api/src/siteOnboarding.d.ts

@@ -2,7 +2,7 @@ import type { Theme } from '../../blocks/src/index';
 import type { SiteVerticalBookingConfig } from '../../core/src/index';
 import { z } from 'zod';
 import type { AiGenerateSiteEntityType, AiGenerateSitePrimaryCta, AiGenerateSiteRequest } from './siteGeneration';
-import type { AppointmentSetupTargetStep } from './appointmentSetup';
+import type { AppointmentSetupReadiness, AppointmentSetupTargetStep } from './appointmentSetup';
 import type { MacadamiaOnboardingLogoAnalysis, MacadamiaOnboardingSurfaceData, PublicOnboardingSurfaceId } from './onboarding/surfaceData';
 export type * from './onboarding/surfaceData';
 /**
@@ -89,8 +89,8 @@ export type AiBrandGuidelinesGenerateResponse = {
         stats: SiteContentSamplingStats;
     };
 };
-export type LaunchRequirementId = 'confirm_email' | 'review_generated_site' | 'configure_appointments' | 'configure_events' | 'configure_courses' | 'connect_payments' | 'connect_custom_domain';
-export type LaunchRequirementPackId = 'core' | 'bookings_appointments' | 'bookings_events' | 'bookings_courses' | 'payments' | 'domain';
+export type LaunchRequirementId = 'confirm_email' | 'review_generated_site' | 'configure_appointments' | 'configure_events' | 'configure_courses' | 'connect_payments' | 'connect_custom_domain' | 'add_first_offering' | 'add_cover_image' | 'add_public_contact';
+export type LaunchRequirementPackId = 'core' | 'bookings_appointments' | 'bookings_events' | 'bookings_courses' | 'payments' | 'domain' | 'offerings' | 'presence';
 export type LaunchRequirementPriority = 'required' | 'recommended' | 'optional';
 export type LaunchRequirementState = 'complete' | 'pending';
 export type LaunchRequirementOwner = 'admin' | 'editor' | 'either';
@@ -162,23 +162,36 @@ export type LaunchAppointmentsPackState = {
     kind: 'disabled';
 } | {
     kind: 'ready';
-} | {
+}
+/** `missing` is the first gap in setup, so copy can name it. */
+ | {
     kind: 'pending_setup';
+    missing: LaunchAppointmentsSetupGap;
     targetStep: AppointmentSetupTargetStep;
 };
+export type LaunchAppointmentsSetupGap = Exclude<AppointmentSetupReadiness['kind'], 'not_applicable' | 'bookable'>;
+/** The event offering kinds a launch item can name (courses have their own item). */
+export declare const LAUNCH_EVENT_OFFERING_KINDS: readonly ["classes", "workshops", "retreats", "performances"];
+export type LaunchEventOfferingKind = (typeof LAUNCH_EVENT_OFFERING_KINDS)[number];
 export type LaunchEventsPackState = {
     kind: 'disabled';
 } | {
     kind: 'ready';
-} | {
+}
+/** `offeredKinds`: event kinds recorded at onboarding, in wizard order; empty when none. */
+ | {
     kind: 'pending_setup';
+    offeredKinds: readonly LaunchEventOfferingKind[];
 };
+/** Keyed on whether a Stripe account exists: `connected_pending` has one that can't take payments yet. */
 export type LaunchPaymentsPackState = {
     kind: 'not_applicable';
 } | {
     kind: 'ready';
 } | {
-    kind: 'pending_setup';
+    kind: 'not_connected';
+} | {
+    kind: 'connected_pending';
 };
 export type LaunchCoursesPackState = {
     kind: 'not_applicable';
@@ -187,6 +200,24 @@ export type LaunchCoursesPackState = {
 } | {
     kind: 'pending_setup';
 };
+/** Booking pages only: whether the site has anything people could book. */
+export type LaunchOfferingsPackState = {
+    kind: 'has_offerings';
+} | {
+    kind: 'none';
+};
+/** Booking pages only. */
+export type LaunchCoverImagePackState = {
+    kind: 'set';
+} | {
+    kind: 'missing';
+};
+/** Booking pages only: whether any contact method is published. */
+export type LaunchPublicContactPackState = {
+    kind: 'published';
+} | {
+    kind: 'missing';
+};
 export type LaunchCustomDomainPackState = {
     kind: 'connected';
     domainIds: readonly string[];
@@ -196,11 +227,28 @@ export type LaunchCustomDomainPackState = {
 } | {
     kind: 'pending_setup';
 };
-export type LaunchRequirement = {
-    id: LaunchRequirementId;
+/**
+ * The exact gap behind a pending requirement, so a presentation can name it
+ * ("Set your hours", "Finish setting up Stripe") without re-deriving facts.
+ */
+export type LaunchAppointmentsGapDetail = {
+    kind: 'appointments_gap';
+    missing: LaunchAppointmentsSetupGap;
+};
+export type LaunchPaymentsGapDetail = {
+    kind: 'payments_gap';
+    stage: 'not_connected' | 'connected_pending';
+};
+export type LaunchEventKindsDetail = {
+    kind: 'event_kinds';
+    offeredKinds: readonly LaunchEventOfferingKind[];
+};
+export type LaunchRequirementDetail = LaunchAppointmentsGapDetail | LaunchPaymentsGapDetail | LaunchEventKindsDetail;
+/** Requirements that always carry a `detail` while pending. */
+export type LaunchDetailedRequirementId = Extract<LaunchRequirementId, 'configure_appointments' | 'connect_payments' | 'configure_events'>;
+type LaunchRequirementFields = {
     packId: LaunchRequirementPackId;
     priority: LaunchRequirementPriority;
-    state: LaunchRequirementState;
     owner: LaunchRequirementOwner;
     title: string;
     description: string;
@@ -208,6 +256,24 @@ export type LaunchRequirement = {
     secondaryAction?: LaunchRequirementAction | null;
     evidence: LaunchRequirementEvidence;
 };
+type LaunchPendingWithDetail<Id extends LaunchDetailedRequirementId, Detail> = LaunchRequirementFields & {
+    id: Id;
+    state: 'pending';
+    detail: Detail;
+};
+/**
+ * One launch requirement. The three detailed items must carry their gap
+ * while pending, so a presentation never has to guess it.
+ */
+export type LaunchRequirement = LaunchPendingWithDetail<'configure_appointments', LaunchAppointmentsGapDetail> | LaunchPendingWithDetail<'connect_payments', LaunchPaymentsGapDetail> | LaunchPendingWithDetail<'configure_events', LaunchEventKindsDetail> | (LaunchRequirementFields & {
+    id: LaunchDetailedRequirementId;
+    state: 'complete';
+    detail?: never;
+}) | (LaunchRequirementFields & {
+    id: Exclude<LaunchRequirementId, LaunchDetailedRequirementId>;
+    state: LaunchRequirementState;
+    detail?: never;
+});
 export type GoLiveDecision = {
     kind: 'allowed';
     overriddenRequirementIds: LaunchRequirementId[];

package/dist/_dts/api/src/sitePlatformEndpoints.d.ts

@@ -23,7 +23,7 @@ export type SdkUpsertNavigationItemInput = Readonly<{
  * Site platform endpoints cover admin/configuration surfaces: redirects, webhooks,
  * keys, SDK management, content-type CRUD, backup flows, and site-level admin tools.
  */
-export type SitePlatformAPIEndpoints = {
+export type SitePlatformAPIEndpoints = import('./sdkEventLifecycle').SdkEventLifecycleAPIEndpoints & {
     listGscPropertiesAdmin: APIEndpoint<never, never, ListGscPropertiesAdminResponse>;
     getPublicChallenge: APIEndpoint<never, never, string>;
     checkRedirect: APIEndpoint<never, CheckRedirectQuery, CheckRedirectResponse>;

package/dist/_dts/api/src/types.d.ts

@@ -12,6 +12,7 @@ export type * from './bookingAdjustments';
 export type * from './bookingConfig';
 export type * from './event-listing-destination';
 export type * from './bookingManagementEndpoints';
+export type * from './newsletterCampaignCommandEndpoints';
 export type * from './bookingOperations';
 export { APPOINTMENT_HISTORY_STATUS_VALUES } from './bookingOperations';
 export type * from './bookingRecords';
@@ -28,6 +29,7 @@ export type * from './sdk-event-payment-terms';
 export type * from './siteInfrastructure';
 export type * from './siteGeneration';
 export type * from './siteManagementEndpoints';
+export type * from './siteAddressEndpoints';
 export type * from './siteOnboarding';
 export type * from './siteOperations';
 export type * from './siteAssets';
@@ -59,18 +61,23 @@ export type { AdminProfileRole, AdminRoleMutationResponse, RevokeAdminRoleReques
 import type { AccountAPIEndpoints } from './accountEndpoints';
 export type * from './accountEndpoints';
 import type { AiAndLaunchReadinessAPIEndpointDefinitions, AiAPIEndpointName, AiAPIEndpoints, LaunchReadinessAPIEndpointName, LaunchReadinessAPIEndpoints } from './aiEndpoints';
+import type { AppointmentServiceCategoryAPIEndpoints } from './appointmentServiceCategoryEndpoints';
 import type { BookingManagementAPIEndpoints } from './bookingManagementEndpoints';
+import type { NewsletterCampaignCommandAPIEndpoints } from './newsletterCampaignCommandEndpoints';
 import type { CommercePortalAPIEndpoints } from './commercePortalEndpoints';
 import type { MailchimpIntegrationAPIEndpoints } from './mailchimpIntegration';
 import type { MailingListIntegrationAPIEndpoints } from './mailingListIntegration';
 import type { PublicExperienceAPIEndpoints } from './publicExperienceEndpoints';
 import type { SeoEndpointDefinitions } from './seoEndpoints';
 import type { SiteManagementAPIEndpoints } from './siteManagementEndpoints';
+import type { SiteAddressAPIEndpoints } from './siteAddressEndpoints';
 import type { SitePlatformAPIEndpoints } from './sitePlatformEndpoints';
+import type { SdkPageDesignAPIEndpoints } from './sdkPageDesign';
 import type { SiteRuntimeAPIEndpoints } from './siteRuntimeEndpoints';
+import type { ClientErrorReportingAPIEndpoints } from './clientErrorReporting';
 type TableName = keyof DbDatabase['public']['Tables'];
 export type DTOType<K extends TableName> = Partial<CamelizeKeys<DbRow<K>>>;
-type APIEndpointsMonolith = AiAndLaunchReadinessAPIEndpointDefinitions & AccountAPIEndpoints & SeoEndpointDefinitions & SiteManagementAPIEndpoints & PublicExperienceAPIEndpoints & SiteRuntimeAPIEndpoints & SitePlatformAPIEndpoints & BookingManagementAPIEndpoints & CommercePortalAPIEndpoints & MailchimpIntegrationAPIEndpoints & MailingListIntegrationAPIEndpoints;
+type APIEndpointsMonolith = AiAndLaunchReadinessAPIEndpointDefinitions & AccountAPIEndpoints & SeoEndpointDefinitions & SiteManagementAPIEndpoints & SiteAddressAPIEndpoints & PublicExperienceAPIEndpoints & SiteRuntimeAPIEndpoints & SitePlatformAPIEndpoints & SdkPageDesignAPIEndpoints & BookingManagementAPIEndpoints & NewsletterCampaignCommandAPIEndpoints & AppointmentServiceCategoryAPIEndpoints & CommercePortalAPIEndpoints & MailchimpIntegrationAPIEndpoints & MailingListIntegrationAPIEndpoints & ClientErrorReportingAPIEndpoints;
 type ComposeEndpointMaps<Maps extends readonly object[], Acc extends object = {}> = Maps extends readonly [
     infer Head extends object,
     ...infer Tail extends readonly object[]

package/dist/_dts/api/src/wholeSeriesRuns.d.ts

@@ -147,3 +147,17 @@ export type UpdateEventSeriesRegistrationRequest = {
 export type UpdateEventSeriesRegistrationResponse = {
     enrollment: EventSeriesRegistrationRecord;
 };
+/**
+ * Somebody on the team filling in or editing the answers of one person on a
+ * booking. A booking can hold several places and each person is asked the
+ * questions separately, so the person is named rather than assumed.
+ */
+export type SaveEventSeriesRegistrationAnswersRequest = {
+    requirementId: string;
+    participantParticipationId: string;
+    answers: Record<string, unknown>;
+};
+export type SaveEventSeriesRegistrationAnswersResponse = {
+    savedAt: string;
+    filledInByName: string;
+};

package/dist/_dts/blocks/src/PageRenderer.d.ts

@@ -4,20 +4,20 @@ import type { PageOutline } from './structure/schema';
 import type { SdkCustomBlock } from './system/manifest/schema';
 import type { RouteMap } from './system/transforms';
 import { type OverrideOnlyRenderMode, type ThemedRenderMode, type TokensOnlyRenderMode } from './pageRenderingMode';
-import { type PageBoundaryWrapper, type PageRuntimeBoundary } from './pageRendererBoundaries';
+import { type PageJoinRenderer, type PageRuntimeJoin } from './pageRendererBoundaries';
 import { type BlockOverrides, type PageRendererDataContext, type SdkConfigForRenderer } from './pageRendererContracts';
 import { type RenderablePageOutline } from './pageRenderAdmission';
 export type { PageBlockRenderAdmissionError, RenderablePageBlock, RenderablePageOutline, } from './pageRenderAdmission';
 export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, OccurrenceContextData, SdkConfigForRenderer, } from './pageRendererContracts';
 export { MissingBlockOverrideError } from './pageRenderingMode';
-export type { PageBlockPosition, PageRuntimeBoundary, } from './pageRendererBoundaries';
+export type { PageBlockPosition, PageJoinRenderer, PageJoinSlot, PageRuntimeJoin, RenderedJoin, } from './pageRendererBoundaries';
 type PageRendererCommonProps<TPage> = {
     page: TPage | null;
-    runtimeBoundaries?: readonly PageRuntimeBoundary[];
+    runtimeJoins?: readonly PageRuntimeJoin[];
     dataContext?: PageRendererDataContext;
     routeMap?: RouteMap;
     wrapBlock?: (blockId: string, rendered: React.ReactNode) => React.ReactNode;
-    wrapBoundary?: PageBoundaryWrapper;
+    renderJoin?: PageJoinRenderer;
     registry?: ResolverContext['registry'];
     blockOverrides?: BlockOverrides;
     sdkConfig?: SdkConfigForRenderer | null;

package/dist/_dts/blocks/src/bindings/index.d.ts

@@ -6,8 +6,8 @@
  */
 export type { BindingSource, BindingDescriptor, BindingInput, BindingMap, BindingContext, BindingPath, BindingTransformName, KnownBindingTransformName, FieldBindingDescriptor, MetaBindingDescriptor, LiteralBindingDescriptor, TransformBindingDescriptor, FallbackBindingDescriptor, } from './types';
 export { TRANSFORMS, BINDING_SOURCES } from './types';
-export { asDesignBlockId, asContentTemplateDesignBlockId, asLayoutVariantKey, buildPageDesignEditorReadModel, compileContentTemplateRuntimeFields, parsePageDesignIntent, surfaceResolutionContextFromTheme, designRuntimeRulesForTheme, type DesignBlockId, parseContentTemplateDesignIntent, type CompiledBlockRuntimeFields, type CompiledBoundaryRuntime, type LayoutVariantKey, type PageDesignEditorBlockInput, type PageDesignIntent, type SurfaceResolutionContext, applyBlockContentVariantPolicy, deriveSiteStyleBlockPolicy, } from '../../../theme-core/src/site-styles/index';
-export { applyCompiledRuntimeFieldsToContent, buildEditorModelRuntimeBoundaries, buildEditorModelRuntimeFieldsByBlockId, compileEditorModelRuntime, retargetCompiledBoundaryRuntimeForContentAdjacency, retargetCompiledRuntimeFieldsForContentAdjacency, } from '../../../theme-core/src/site-styles/previewCompiler';
+export { asDesignBlockId, asContentTemplateDesignBlockId, asLayoutVariantKey, buildPageDesignEditorReadModel, compileContentTemplateRuntimeFields, parsePageDesignIntent, surfaceResolutionContextFromTheme, designRuntimeRulesForTheme, type DesignBlockId, parseContentTemplateDesignIntent, type CompiledBlockRuntimeFields, type PageRuntimeJoin, type LayoutVariantKey, type PageDesignEditorBlockInput, type PageDesignIntent, type SurfaceResolutionContext, applyBlockContentVariantPolicy, deriveSiteStyleBlockPolicy, } from '../../../theme-core/src/site-styles/index';
+export { applyCompiledRuntimeFieldsToContent, buildEditorModelRuntimeFieldsByBlockId, compileEditorModelRuntime, } from '../../../theme-core/src/site-styles/previewCompiler';
 export { blockDesignMetadataMapFromDefinitions } from '../system/designCapabilities';
 export { systemBlockDefinitions } from '../system/blocks';
 import type { BindingContext, BindingDescriptor, BindingInput, BindingMap, BindingPath, FieldBindingDescriptor, FallbackBindingDescriptor, KnownBindingTransformName, LiteralBindingDescriptor, MetaBindingDescriptor, TransformBindingDescriptor } from './types';

package/dist/_dts/blocks/src/contracts/proof-block-islands.d.ts

@@ -87,6 +87,12 @@ export declare const proofBlockIslandCodecs: {
                             agreement: import("../../../core/src/index").RichTextDoc;
                             checkboxLabel: string;
                         }>;
+                        categoryId?: string | null;
+                    }>[];
+                    serviceCategories?: readonly Readonly<{
+                        id: string;
+                        name: string;
+                        description: string | null;
                     }>[];
                     spamProtectionEnabled?: boolean;
                 }>;
@@ -169,6 +175,12 @@ export declare const proofBlockIslandCodecs: {
                             agreement: import("../../../core/src/index").RichTextDoc;
                             checkboxLabel: string;
                         }>;
+                        categoryId?: string | null;
+                    }>[];
+                    serviceCategories?: readonly Readonly<{
+                        id: string;
+                        name: string;
+                        description: string | null;
                     }>[];
                     spamProtectionEnabled?: boolean;
                 }>;
@@ -1037,6 +1049,12 @@ export declare const runtimeIslandCodecs: {
                             agreement: import("../../../core/src/index").RichTextDoc;
                             checkboxLabel: string;
                         }>;
+                        categoryId?: string | null;
+                    }>[];
+                    serviceCategories?: readonly Readonly<{
+                        id: string;
+                        name: string;
+                        description: string | null;
                     }>[];
                     spamProtectionEnabled?: boolean;
                 }>;
@@ -1119,6 +1137,12 @@ export declare const runtimeIslandCodecs: {
                             agreement: import("../../../core/src/index").RichTextDoc;
                             checkboxLabel: string;
                         }>;
+                        categoryId?: string | null;
+                    }>[];
+                    serviceCategories?: readonly Readonly<{
+                        id: string;
+                        name: string;
+                        description: string | null;
                     }>[];
                     spamProtectionEnabled?: boolean;
                 }>;

package/dist/_dts/blocks/src/index.d.ts

@@ -2,8 +2,10 @@ export { default as PageRenderer, EditorPageRenderer } from './PageRenderer';
 export type { RenderAudience as PageRenderAudience } from './pageRenderAudience';
 export { createCustomBlockRegistry, mergeBlockDescriptorsWithRegistry, planCustomBlockRegistryResolution, transformToBlockDescriptor, } from './customBlockRegistry';
 export type { CustomBlockConflictReason, CustomBlockManifestSource, CustomBlockRegistry, CustomBlockRegistryConflict, CustomBlockRegistryEntry, CustomBlockRegistryResolutionPlan, CustomBlockSourcePolicy, ResolvedCustomBlockManifest, SdkConfigForBlockPicker, } from './customBlockRegistry';
-export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, EditorPageRendererProps, PageBlockRenderAdmissionError, PageRendererProps, RenderablePageBlock, RenderablePageOutline, OccurrenceContextData, PageBlockPosition, PageRuntimeBoundary, SdkConfigForRenderer, } from './PageRenderer';
+export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, EditorPageRendererProps, PageBlockRenderAdmissionError, PageRendererProps, RenderablePageBlock, RenderablePageOutline, OccurrenceContextData, PageBlockPosition, PageJoinRenderer, PageJoinSlot, PageRuntimeJoin, RenderedJoin, SdkConfigForRenderer, } from './PageRenderer';
 export { MissingBlockOverrideError } from './pageRenderingMode';
+export { readPublishedBlockPlacement } from './pageRenderAdmission';
+export type { PublishedBlockPlacement } from './pageRenderAdmission';
 export * from './subroutes';
 export * from './structure/schema';
 export { BLOCK_BUTTON_ROLES, BLOCK_BUTTON_ROLE_OPTIONS, blockButtonRoleSchema, isBlockButtonRole, type BlockButtonRole, } from './system/constants/buttonRoles';

package/dist/_dts/blocks/src/pageRenderAdmission.d.ts

@@ -6,12 +6,20 @@ export type PageBlockRenderAdmissionError = Readonly<{
 }> | Readonly<{
     kind: 'manifest_unavailable';
 }>;
+export type PublishedBlockPlacement = Readonly<{
+    id: string;
+    content: Record<string, unknown>;
+}>;
+/** Pair a published version with the content it authorises at the render boundary. */
+export declare function readPublishedBlockPlacement(id: string | null | undefined, content: Record<string, unknown> | null | undefined): PublishedBlockPlacement | null;
 export type RenderablePageBlock = Readonly<{
     id: Block['id'];
     kind: Block['kind'];
     purpose: Block['purpose'];
     bindings?: Block['bindings'];
     contentVersionId?: string | null;
+    draftContentId?: string | null;
+    publishedPlacement?: PublishedBlockPlacement | null;
     admission: Readonly<{
         kind: 'renderable';
         content: RenderableManifestContent;
@@ -34,6 +42,8 @@ export type PresentationAdmission = Readonly<{
 export type PresentationBlock = Block & Readonly<{
     presentationAdmission: PresentationAdmission;
     contentVersionId?: string | null;
+    draftContentId?: string | null;
+    publishedPlacement?: PublishedBlockPlacement | null;
 }>;
 export type PresentationPageOutline = Omit<PageOutline, 'blocks'> & Readonly<{
     blocks: readonly PresentationBlock[];

package/dist/_dts/blocks/src/pageRenderJoins.d.ts

@@ -0,0 +1,68 @@
+import { type BoundaryLayout, type BoundaryOutcome, type DecorativeTransitionIntent, type DesignBoundaryId, type PageRuntimeJoin as ThemeCorePageRuntimeJoin } from '../../theme-core/src/site-styles/index';
+/**
+ * A break between two adjacent blocks as the server sends it: intent only.
+ * Everything visual is decided here, from the content that finally renders
+ * (issue 1422).
+ */
+export type PageRuntimeJoin = ThemeCorePageRuntimeJoin<string>;
+/**
+ * A join after composition: its treatment plus whether and how it draws. The
+ * outcome comes from the same composition as the painted markup, so the
+ * editor's "won't show here" note can never disagree with the page.
+ */
+export type RenderedJoin = Readonly<{
+    boundaryId: DesignBoundaryId;
+    previousBlockId: string;
+    nextBlockId: string;
+    treatment: DecorativeTransitionIntent;
+    outcome: BoundaryOutcome;
+}>;
+/**
+ * One adjacent pair of surviving blocks. `join` is null when the pair has no
+ * break at all; a join that exists but does not draw carries a not-shown
+ * outcome instead.
+ */
+export type PageJoinSlot = Readonly<{
+    previousBlockId: string;
+    nextBlockId: string;
+    join: RenderedJoin | null;
+}>;
+/** The survivor facts composition needs: its id, kind and final content. */
+export type JoinSurvivor = Readonly<{
+    id: string | null | undefined;
+    kind: string;
+    content: Record<string, unknown>;
+}>;
+/**
+ * Re-points joins across omitted blocks. Pure over joins.
+ *
+ * Joins are keyed by adjacent block-id pairs, so dropping B from [A, B, C]
+ * removes the A→C join as well as B's own, because no A→C join was ever
+ * resolved. For each surviving pair the original join is kept when the pair
+ * was already adjacent. Across a gap, the treatment comes from the join
+ * entering the omitted run (A→first omitted), falling back to the one leaving
+ * it (last omitted→C). Nothing visual is carried: the survivors are composed
+ * from their own content afterwards.
+ *
+ * `survivors` are compared by identity against `originalBlocks`.
+ */
+export declare function retargetJoinsAcrossOmissions<TBlock extends Readonly<{
+    id?: string | null;
+}>>(input: Readonly<{
+    joins: readonly PageRuntimeJoin[];
+    originalBlocks: readonly TBlock[];
+    survivingBlocks: ReadonlySet<TBlock>;
+}>): readonly PageRuntimeJoin[];
+/**
+ * The single composition site. For every adjacent pair of survivors with ids,
+ * finds its join and composes it from both survivors' final content: what
+ * each paints with and the frame each draws.
+ */
+export declare function composePageJoins(input: Readonly<{
+    joins: readonly PageRuntimeJoin[];
+    survivors: readonly JoinSurvivor[];
+}>): readonly PageJoinSlot[];
+/** Placement, reserves and paint for a join that draws; null otherwise. */
+export declare function renderedJoinLayout(join: RenderedJoin | null): BoundaryLayout | null;
+/** Slot lookup key for an adjacent pair, in the one boundary-id scheme. */
+export declare function joinSlotKey(previousBlockId: string, nextBlockId: string): DesignBoundaryId;

package/dist/_dts/blocks/src/pageRenderPlan.d.ts

@@ -1,7 +1,7 @@
 import { getBlockDefinition } from './system';
 import type { SdkCustomBlock } from './system/manifest/schema';
 import type { PresentationBlock, PresentationPageOutline } from './pageRenderAdmission';
-import { type PageRuntimeBoundary } from './pageRendererBoundaries';
+import { type PageRuntimeJoin } from './pageRenderJoins';
 import type { BlockOverrideComponent, BlockOverrides, SdkConfigForRenderer } from './pageRendererContracts';
 import type { NotRenderableReason, RenderAudience } from './pageRenderAudience';
 type ResolvedBlockDefinition = NonNullable<ReturnType<typeof getBlockDefinition>>;
@@ -70,12 +70,17 @@ export type OmittedBlockDebugFields = Readonly<{
 export type PageRenderPlan = Readonly<{
     entries: readonly PageBlockRenderPlanEntry[];
     omitted: readonly OmittedPageBlock[];
-    runtimeBoundaries: readonly PageRuntimeBoundary[] | undefined;
+    /**
+     * Joins between the plan's entries, re-pointed across plan-time omissions.
+     * A caller that sent no joins gets an empty list: every pair still gets a
+     * join slot, with no treatment.
+     */
+    runtimeJoins: readonly PageRuntimeJoin[];
 }>;
 export type BuildPageRenderPlanInput = Readonly<{
     page: PresentationPageOutline;
     audience: RenderAudience;
-    runtimeBoundaries: readonly PageRuntimeBoundary[] | undefined;
+    runtimeJoins: readonly PageRuntimeJoin[] | undefined;
     previewStage: 'published' | 'preview';
     sdkConfig: SdkConfigForRenderer | null | undefined;
     customBlocks: readonly SdkCustomBlock[] | undefined;
@@ -89,28 +94,4 @@ export type BuildPageRenderPlanInput = Readonly<{
  * runs inside a `useMemo` whose recomputation React makes no promises about.
  */
 export declare function buildPageRenderPlan(input: BuildPageRenderPlanInput): PageRenderPlan;
-/**
- * Re-points section boundaries across omitted blocks.
- *
- * Boundaries are keyed by adjacent block-id *pairs*, so dropping B from
- * [A, B, C] does not merely remove B's boundaries — it removes the boundary
- * between the survivors, because no `A→C` key was ever compiled.
- *
- * Per decision D2 the treatment for a merged gap comes from the boundary
- * entering the omitted run (`A→firstOmitted`), falling back to the one leaving
- * it (`lastOmitted→C`). The destination surface is a separate question: only
- * the exiting boundary knows what C looks like, so the merged boundary ends on
- * that endpoint rather than on the omitted block's. In the exiting-only
- * fallback the origin remains an approximation: `from` is the omitted block's
- * surface, because no compiled boundary carries A's. The hosted path no longer
- * needs this at all (site-renderer admits blocks before compiling boundaries);
- * it remains the safety net for an SDK whose compiled boundaries predate an
- * omission.
- */
-export declare function retargetBoundariesAcrossOmissions(input: Readonly<{
-    boundaries: readonly PageRuntimeBoundary[] | undefined;
-    originalBlocks: readonly PresentationBlock[];
-    survivingBlocks: ReadonlySet<PresentationBlock>;
-    previewStage: 'published' | 'preview';
-}>): readonly PageRuntimeBoundary[] | undefined;
 export {};

package/dist/_dts/blocks/src/pageRenderPreparation.d.ts

@@ -4,9 +4,9 @@ import type { ResolveImageUrlContext } from './system/runtime/nodes/media';
 import { type PageThemeResources } from './pageRenderingMode';
 import type { PresentationBlock } from './pageRenderAdmission';
 import type { RenderAudience } from './pageRenderAudience';
-import type { PageRuntimeBoundary } from './pageRendererBoundaries';
+import { type PageJoinSlot } from './pageRenderJoins';
 import type { BlockOverrideProps, PageRendererDataContext } from './pageRendererContracts';
-import { type PageBlockRenderPlanEntry, type PageRenderPlan } from './pageRenderPlan';
+import type { PageBlockRenderPlanEntry, PageRenderPlan } from './pageRenderPlan';
 /**
  * What preparing a block produced.
  *
@@ -46,7 +46,11 @@ export type PageRenderPreparation = Readonly<{
      * has to replay the overrides-only guard over the entry's own `override`.
      */
     constructionFailures: readonly PageBlockRenderPlanEntry[];
-    runtimeBoundaries: readonly PageRuntimeBoundary[] | undefined;
+    /**
+     * One slot per adjacent pair of surviving entries, composed from their final
+     * content after both kinds of omission.
+     */
+    joins: readonly PageJoinSlot[];
 }>;
 export type PreparePageRenderInput = Readonly<{
     plan: PageRenderPlan;
@@ -55,7 +59,6 @@ export type PreparePageRenderInput = Readonly<{
     routeMap: RouteMap | undefined;
     themeResources: PageThemeResources;
     imageResolveContext: ResolveImageUrlContext;
-    previewStage: 'published' | 'preview';
 }>;
 /**
  * Stage two of the render plan.

package/dist/_dts/blocks/src/pageRendererBoundaries.d.ts

@@ -1,31 +1,48 @@
 import React from 'react';
-import type { CompiledBoundaryRuntime } from '../../theme-core/src/site-styles/index';
-import type { Block } from './structure/schema';
+import type { BoundaryLayout } from '../../theme-core/src/site-styles/index';
+import { type PageJoinSlot, type RenderedJoin } from './pageRenderJoins';
 export type PageBlockPosition = 'only' | 'first' | 'middle' | 'last';
-export type PageRuntimeBoundary = CompiledBoundaryRuntime<string>;
-export type PageBoundaryWrapper = (boundary: PageRuntimeBoundary, rendered: React.ReactNode) => React.ReactNode;
-export declare const boundaryKey: (previousBlockId: string, nextBlockId: string) => string;
-export declare function isSiteStyleTransitionStyleGroup(value: string | undefined): value is string;
-export declare function boundaryMapForAdjacentBlockIds(boundaries: readonly PageRuntimeBoundary[]): ReadonlyMap<string, PageRuntimeBoundary>;
-export declare function boundaryBetweenBlocks(previousBlock: Block | null, nextBlock: Block | null, boundaries: ReadonlyMap<string, PageRuntimeBoundary>): PageRuntimeBoundary | null;
-export declare function renderBoundaryAfterBlock(input: Readonly<{
-    block: Block;
-    nextBlock: Block | null;
+export type { PageJoinSlot, PageRuntimeJoin, RenderedJoin, } from './pageRenderJoins';
+/**
+ * Called once for every adjacent pair of surviving blocks, including pairs
+ * with no join and joins that do not draw. What it returns is rendered at the
+ * join, after any painted boundary element. The editor mounts its section
+ * break control here, so the control exists even when nothing is painted.
+ */
+export type PageJoinRenderer = (input: Readonly<{
+    previousBlockId: string;
+    nextBlockId: string;
+    join: RenderedJoin | null;
+}>) => React.ReactNode;
+export declare function joinSlotsByPair(slots: readonly PageJoinSlot[]): ReadonlyMap<string, PageJoinSlot>;
+export declare function joinSlotBetween(previousBlockId: string | null | undefined, nextBlockId: string | null | undefined, slots: ReadonlyMap<string, PageJoinSlot>): PageJoinSlot | null;
+/**
+ * The markup at one join: the painted boundary element when the join draws,
+ * then whatever `renderJoin` adds. Null when there is nothing to render.
+ */
+export declare function renderJoinSlot(input: Readonly<{
+    slot: PageJoinSlot | null;
     blockKey: string;
-    boundaryByAdjacentBlockIds: ReadonlyMap<string, PageRuntimeBoundary>;
-    wrapBoundary?: PageBoundaryWrapper;
+    renderJoin: PageJoinRenderer | undefined;
 }>): React.ReactNode;
-type TransitionCssVarsStyle = React.CSSProperties & {
-    '--site-style-transition-from'?: string;
-    '--site-style-transition-to'?: string;
+type BoundaryStyle = React.CSSProperties & {
+    '--boundary-shape-paint'?: string;
+    '--boundary-band-paint'?: string;
     '--site-style-boundary-before-reserve'?: string;
     '--site-style-boundary-after-reserve'?: string;
 };
-export declare function boundaryReserveCssVarsStyle(input: Readonly<{
-    before: PageRuntimeBoundary | null;
-    after: PageRuntimeBoundary | null;
-}>): TransitionCssVarsStyle | undefined;
-export declare function transitionCssVarsStyle(content: Record<string, unknown>): TransitionCssVarsStyle | undefined;
-export declare function mergeStyleObjects(left: TransitionCssVarsStyle | undefined, right: TransitionCssVarsStyle | undefined): TransitionCssVarsStyle | undefined;
+/**
+ * Reserve attributes and variables for a block wrapper, from the joins on
+ * either side. A join's `before` reserve sits inside its previous section, so
+ * it pads the bottom of the block above the join; its `after` reserve pads the
+ * top of the block below. Joins that do not draw reserve nothing.
+ */
+export declare function blockBoundaryReserves(input: Readonly<{
+    before: PageJoinSlot | null;
+    after: PageJoinSlot | null;
+}>): Readonly<{
+    topPlacement: BoundaryLayout['placement'] | undefined;
+    bottomPlacement: BoundaryLayout['placement'] | undefined;
+    style: BoundaryStyle | undefined;
+}>;
 export declare function pageBlockPosition(index: number, blockCount: number): PageBlockPosition;
-export {};

package/dist/_dts/blocks/src/pageRendererContracts.d.ts

@@ -7,6 +7,7 @@ import type { RouteMap } from './system/transforms';
 import type { BookingOfferingPresetSummary } from './system/blocks/offerings-preview/model';
 import type { BlockLoaderFailures } from './system/data/types';
 import type { BrowserReadAuthority } from './system/runtime/api/types';
+import type { NewsletterBlockSubmission } from './system/runtime/nodes/newsletter-form.block-submission';
 /**
  * Occurrence context for event pages.
  * Passed through to blocks that need occurrence information (e.g., event-registration).
@@ -76,6 +77,7 @@ export type BlockOverrideProps<TContent = Record<string, unknown>> = {
     blockId: string | null;
     /** Exact content snapshot rendered for this block. */
     contentVersionId?: string | null;
+    newsletterBlockSubmission?: NewsletterBlockSubmission;
     /** Block kind identifier (e.g., "block.hero" or "custom.my-block") */
     blockKind: string;
 };
@@ -141,7 +143,7 @@ export type PageRendererDataContext = {
     resolvedData?: Record<string, Record<string, unknown>>;
     /** Failed server loader requests, kept separate from successful data. */
     loaderFailures?: BlockLoaderFailures;
-    previewStage?: 'published' | 'preview';
+    previewStage: 'published' | 'preview';
     previewToken?: string | null;
     readAuthority?: BrowserReadAuthority;
     routes?: RouteMap;

package/dist/_dts/blocks/src/server.d.ts

@@ -1,5 +1,5 @@
 export { default as PageRenderer, EditorPageRenderer, MissingBlockOverrideError, } from './PageRenderer';
 export type { RenderAudience as PageRenderAudience } from './pageRenderAudience';
-export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, EditorPageRendererProps, OccurrenceContextData, PageBlockRenderAdmissionError, PageBlockPosition, PageRuntimeBoundary, RenderablePageBlock, RenderablePageOutline, SdkConfigForRenderer, } from './PageRenderer';
+export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, EditorPageRendererProps, OccurrenceContextData, PageBlockRenderAdmissionError, PageBlockPosition, PageJoinRenderer, PageJoinSlot, PageRuntimeJoin, RenderedJoin, RenderablePageBlock, RenderablePageOutline, SdkConfigForRenderer, } from './PageRenderer';
 export * from './subroutes';
 export { ThemeScope } from '../../theme-core/src/ThemeScope';

package/dist/_dts/blocks/src/system/blocks/appointment-services.d.ts

@@ -5,6 +5,8 @@ declare const appointmentServicesManifest: BlockManifest;
 export type AppointmentServicesContent = Readonly<{
     heading?: string | null;
     description?: unknown;
+    /** Issue 1403: one category to show; unset shows every category grouped. */
+    categoryId?: string | null;
     _sectionStyles?: SectionStylesContent;
 }>;
 export declare const appointmentServicesBlockDefinition: SystemBlockDefinition<AppointmentServicesContent>;