@riverbankcms/sdk 0.147.0 → 0.149.0

package/dist/_dts/realtime/src/draftChannel.d.ts

@@ -0,0 +1,91 @@
+import { type DraftStateMessage, type DraftSyncRequestMessage } from './drafts';
+/**
+ * Structural slice of a Supabase client that the drafts channel needs, so this
+ * package stays free of a supabase-js dependency. A `SupabaseClient` satisfies
+ * it (proved by the realtime drafts integration test).
+ *
+ * Method syntax keeps parameter checks bivariant, which is what lets the real
+ * overloaded Supabase methods satisfy these narrower signatures.
+ */
+export type DraftBroadcastChannel = {
+    on(type: 'broadcast', filter: {
+        event: string;
+    }, callback: (message: {
+        payload: unknown;
+    }) => void): unknown;
+    subscribe(callback: (status: string, error?: Error) => void): unknown;
+    send(args: {
+        type: 'broadcast';
+        event: string;
+        payload: unknown;
+    }): Promise<DraftSendResult>;
+};
+export type DraftChannelOptions = {
+    config: {
+        private: true;
+        broadcast: {
+            self: false;
+        };
+    };
+};
+export type DraftRealtimeClient = {
+    channel(name: string, options: DraftChannelOptions): DraftBroadcastChannel;
+    removeChannel(channel: DraftBroadcastChannel): unknown;
+    realtime: {
+        setAuth(token?: string | null): Promise<void>;
+    };
+};
+export type DraftSendResult = 'ok' | 'timed out' | 'error';
+/**
+ * How the channel authenticates:
+ * - `session`: the client's own Supabase auth session (dashboard). supabase-js
+ *   already forwards the session token and its refreshes to Realtime.
+ * - `token`: an explicit access token (preview), applied with
+ *   `realtime.setAuth(token)`. Note this pins the token for every channel on
+ *   that client until `setAuth()` is called without arguments.
+ */
+export type DraftChannelAuth = Readonly<{
+    kind: 'session';
+}> | Readonly<{
+    kind: 'token';
+    accessToken: string;
+}>;
+/** Subscribe status as reported by realtime-js, narrowed to what callers act on. */
+export type DraftChannelStatus = 'joining' | 'joined' | 'timed-out' | 'error' | 'closed';
+export type DraftChannelHandlers = Readonly<{
+    onDraftState?: (message: DraftStateMessage) => void;
+    onSyncRequest?: (message: DraftSyncRequestMessage) => void;
+    onStatus?: (status: DraftChannelStatus, error?: Error) => void;
+    onInvalidMessage?: (event: string, error: unknown) => void;
+}>;
+export type DraftChannelConnection = Readonly<{
+    sendDraftState: (message: DraftStateMessage) => Promise<DraftSendResult>;
+    sendSyncRequest: (message: DraftSyncRequestMessage) => Promise<DraftSendResult>;
+    /**
+     * Apply a rotated token to the live connection. realtime-js pushes it to
+     * every joined channel, where Realtime re-evaluates the RLS policies; no
+     * rejoin is needed while the channel is healthy (see `planDraftAuthChange`).
+     */
+    setAccessToken: (accessToken: string) => Promise<void>;
+    leave: () => Promise<void>;
+}>;
+export declare function toDraftChannelStatus(status: string): DraftChannelStatus;
+/**
+ * A token change on a healthy (or still joining) channel is applied in place.
+ * A channel that was closed, timed out or refused (typically because the old
+ * token expired or lacked access) is rebuilt with the new token.
+ */
+export declare function planDraftAuthChange(status: DraftChannelStatus): 'reauthorise' | 'rejoin';
+/**
+ * Join the private `site:{siteId}:drafts` channel. Validates every incoming
+ * message at the boundary; filtering by scope and origin/seq is the caller's
+ * decision (`isDraftForScope`, `acceptDraftState`).
+ *
+ * With token auth the join waits for `setAuth` so the join carries the token.
+ */
+export declare function joinDraftChannel(options: Readonly<{
+    client: DraftRealtimeClient;
+    siteId: string;
+    auth: DraftChannelAuth;
+    handlers: DraftChannelHandlers;
+}>): DraftChannelConnection;

package/dist/_dts/realtime/src/drafts.d.ts

@@ -0,0 +1,210 @@
+import { z } from 'zod';
+import { type RealtimeEditScope } from './types';
+/**
+ * Live drafts (issue 1545): unsaved field values streamed from the editing tab to
+ * preview tabs over the PRIVATE channel `site:{siteId}:drafts`. Access is
+ * enforced by RLS on realtime.messages (only editors of the site may join or
+ * send), so nothing here is a security boundary; these schemas are the parse
+ * boundary for whatever arrives.
+ */
+export declare const DRAFT_STATE_EVENT = "draft-state";
+export declare const DRAFT_SYNC_REQUEST_EVENT = "draft-sync-request";
+/** Per-item limit: an item whose JSON exceeds this is not streamed. */
+export declare const DRAFT_ITEM_MAX_BYTES = 200000;
+/**
+ * Whole-message budget, kept under Realtime's smallest plan limit (256 KB) with
+ * room for the envelope.
+ */
+export declare const DRAFT_MESSAGE_MAX_BYTES = 240000;
+export declare const draftItemStateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"unsaved">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"saved">;
+    revision: z.ZodString;
+}, z.core.$strip>], "kind">;
+declare const draftTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"block">;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"content">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"linked-entry">;
+    id: z.ZodString;
+}, z.core.$strip>], "kind">;
+/** A draft item is its target plus the streamed values and their state. */
+export declare const draftItemSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    state: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"unsaved">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"saved">;
+        revision: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    kind: z.ZodLiteral<"block">;
+    id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    state: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"unsaved">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"saved">;
+        revision: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    kind: z.ZodLiteral<"content">;
+}, z.core.$strip>, z.ZodObject<{
+    values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    state: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"unsaved">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"saved">;
+        revision: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    kind: z.ZodLiteral<"linked-entry">;
+    id: z.ZodString;
+}, z.core.$strip>], "kind">;
+export declare const draftStateMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"draft-state">;
+    siteId: z.ZodString;
+    scope: z.ZodObject<{
+        nodeType: z.ZodEnum<{
+            page: "page";
+            content_entry: "content_entry";
+            page_surface: "page_surface";
+        }>;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+    origin: z.ZodString;
+    seq: z.ZodNumber;
+    sentAt: z.ZodNumber;
+    items: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        state: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"unsaved">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"saved">;
+            revision: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        kind: z.ZodLiteral<"block">;
+        id: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        state: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"unsaved">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"saved">;
+            revision: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        kind: z.ZodLiteral<"content">;
+    }, z.core.$strip>, z.ZodObject<{
+        values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        state: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"unsaved">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"saved">;
+            revision: z.ZodString;
+        }, z.core.$strip>], "kind">;
+        kind: z.ZodLiteral<"linked-entry">;
+        id: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export declare const draftSyncRequestMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"draft-sync-request">;
+    siteId: z.ZodString;
+    scope: z.ZodObject<{
+        nodeType: z.ZodEnum<{
+            page: "page";
+            content_entry: "content_entry";
+            page_surface: "page_surface";
+        }>;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+    origin: z.ZodString;
+}, z.core.$strip>;
+export type DraftItemState = z.infer<typeof draftItemStateSchema>;
+export type DraftTarget = z.infer<typeof draftTargetSchema>;
+export type DraftItem = z.infer<typeof draftItemSchema>;
+export type DraftItemKind = DraftItem['kind'];
+export type DraftStateMessage = z.infer<typeof draftStateMessageSchema>;
+export type DraftSyncRequestMessage = z.infer<typeof draftSyncRequestMessageSchema>;
+export type DraftChannelEvent = typeof DRAFT_STATE_EVENT | typeof DRAFT_SYNC_REQUEST_EVENT;
+export type DraftParseResult<T> = Readonly<{
+    kind: 'valid';
+    message: T;
+}> | Readonly<{
+    kind: 'invalid';
+    error: z.ZodError;
+}>;
+export declare function parseDraftStateMessage(data: unknown): DraftParseResult<DraftStateMessage>;
+export declare function parseDraftSyncRequestMessage(data: unknown): DraftParseResult<DraftSyncRequestMessage>;
+/**
+ * Get the private Realtime channel name for a site's live drafts. The RLS
+ * policies only authorise exactly this shape, with a lowercase uuid.
+ */
+export declare function getDraftChannelName(siteId: string): `site:${string}:drafts`;
+/** Stable key for a target, for overlays keyed by item. */
+export declare function draftTargetKey(target: DraftTarget): string;
+/** An item's key is its target's key. */
+export declare function draftItemKey(item: DraftItem): string;
+/** True when a message is for the given site and document scope. */
+export declare function isDraftForScope(message: Readonly<{
+    siteId: string;
+    scope: RealtimeEditScope;
+}>, view: Readonly<{
+    siteId: string;
+    scope: RealtimeEditScope;
+}>): boolean;
+export type DraftSeqByOrigin = ReadonlyMap<string, number>;
+export type DraftStateDecision = Readonly<{
+    kind: 'accept';
+    latestSeqByOrigin: DraftSeqByOrigin;
+}> | Readonly<{
+    kind: 'ignore';
+    reason: 'own-origin' | 'stale-seq';
+}>;
+/**
+ * Decide whether an incoming draft-state should be applied. Messages from this
+ * tab's own origin, and any whose seq is not newer than the last accepted seq
+ * from the same origin, are ignored. Accepting returns the next seq map; the
+ * input map is never mutated.
+ *
+ * Emitters must keep seq strictly increasing per origin for the origin's
+ * lifetime: if an origin id outlives a page load, seed seq from a clock rather
+ * than restarting at 0, or viewers will ignore it as stale.
+ */
+export declare function acceptDraftState(latestSeqByOrigin: DraftSeqByOrigin, message: Pick<DraftStateMessage, 'origin' | 'seq'>, selfOrigin: string | null): DraftStateDecision;
+export type DroppedDraftItem = Readonly<{
+    key: string;
+    kind: DraftItemKind;
+    bytes: number;
+    reason: 'item-too-large' | 'message-budget';
+}>;
+export type DraftItemSizePlan = Readonly<{
+    kept: readonly DraftItem[];
+    dropped: readonly DroppedDraftItem[];
+}>;
+/** Byte length of an item's JSON, as it would travel. */
+export declare function measureDraftItemBytes(item: DraftItem): number;
+/**
+ * Split items into those that can be streamed and those that are dropped and
+ * reported. An item over `maxItemBytes` is always dropped; after that, items are
+ * kept in order until `maxMessageBytes` would be exceeded. A dropped item simply
+ * isn't live; the viewer still sees it after autosave and reload.
+ */
+export declare function planDraftItemsBySize(items: readonly DraftItem[], limits?: Readonly<{
+    maxItemBytes?: number;
+    maxMessageBytes?: number;
+}>): DraftItemSizePlan;
+export declare function createDraftStateMessage(options: Readonly<{
+    siteId: string;
+    scope: RealtimeEditScope;
+    origin: string;
+    seq: number;
+    items: readonly DraftItem[];
+    sentAt?: number;
+}>): DraftStateMessage;
+export declare function createDraftSyncRequestMessage(options: Readonly<{
+    siteId: string;
+    scope: RealtimeEditScope;
+    origin: string;
+}>): DraftSyncRequestMessage;
+export {};

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

@@ -0,0 +1,3 @@
+export { realtimeReloadPayloadSchema, realtimeLeaseChangedPayloadSchema, realtimeSiteEventSchema, type RealtimeReloadPayload, type RealtimeLeaseChangedPayload, type RealtimeSiteEvent, getPreviewChannelName, validateReloadPayload, validateSiteEvent, createReloadPayload, createLeaseChangedPayload, shouldReloadForClient, } from './types';
+export { realtimeEditScopeSchema, type RealtimeEditScope, } from './types';
+export { DRAFT_STATE_EVENT, DRAFT_SYNC_REQUEST_EVENT, DRAFT_ITEM_MAX_BYTES, DRAFT_MESSAGE_MAX_BYTES, draftItemStateSchema, draftItemSchema, draftStateMessageSchema, draftSyncRequestMessageSchema, type DraftItemState, type DraftTarget, type DraftItem, type DraftItemKind, type DraftStateMessage, type DraftSyncRequestMessage, type DraftChannelEvent, type DraftParseResult, type DraftSeqByOrigin, type DraftStateDecision, type DroppedDraftItem, type DraftItemSizePlan, parseDraftStateMessage, parseDraftSyncRequestMessage, getDraftChannelName, draftTargetKey, draftItemKey, isDraftForScope, acceptDraftState, measureDraftItemBytes, planDraftItemsBySize, createDraftStateMessage, createDraftSyncRequestMessage, } from './drafts';

package/dist/_dts/realtime/src/leaseChangeSubscriptions.d.ts

@@ -0,0 +1,8 @@
+import type { RealtimeLeaseChangedPayload } from './types';
+type Scope = RealtimeLeaseChangedPayload['scope'];
+/** One site channel dispatches only to mounted controllers for the changed scope. */
+export declare function createLeaseChangeSubscriptions(): {
+    subscribe: (scope: Scope, listener: () => void) => () => void;
+    notify: (scope: Scope) => void;
+};
+export {};

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

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+/**
+ * Zod schema for real-time reload broadcast payloads.
+ *
+ * Validates that broadcasts contain:
+ * - siteId: UUID of the site being updated
+ * - resource: Type of resource changed (theme, page, content)
+ * - resourceId: Optional UUID of specific resource (e.g., pageId, entryId)
+ * - timestamp: Unix timestamp (ms) when broadcast was sent
+ */
+export declare const realtimeReloadPayloadSchema: z.ZodObject<{
+    type: z.ZodLiteral<"reload">;
+    siteId: z.ZodString;
+    resource: z.ZodEnum<{
+        content: "content";
+        page: "page";
+        theme: "theme";
+    }>;
+    resourceId: z.ZodOptional<z.ZodString>;
+    origin: z.ZodNullable<z.ZodString>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+/** The editable document an edit lease or a live draft belongs to. */
+export declare const realtimeEditScopeSchema: z.ZodObject<{
+    nodeType: z.ZodEnum<{
+        page: "page";
+        content_entry: "content_entry";
+        page_surface: "page_surface";
+    }>;
+    nodeId: z.ZodString;
+}, z.core.$strip>;
+export type RealtimeEditScope = z.infer<typeof realtimeEditScopeSchema>;
+export declare const realtimeLeaseChangedPayloadSchema: z.ZodObject<{
+    type: z.ZodLiteral<"lease-changed">;
+    siteId: z.ZodString;
+    scope: z.ZodObject<{
+        nodeType: z.ZodEnum<{
+            page: "page";
+            content_entry: "content_entry";
+            page_surface: "page_surface";
+        }>;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const realtimeSiteEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"reload">;
+    siteId: z.ZodString;
+    resource: z.ZodEnum<{
+        content: "content";
+        page: "page";
+        theme: "theme";
+    }>;
+    resourceId: z.ZodOptional<z.ZodString>;
+    origin: z.ZodNullable<z.ZodString>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"lease-changed">;
+    siteId: z.ZodString;
+    scope: z.ZodObject<{
+        nodeType: z.ZodEnum<{
+            page: "page";
+            content_entry: "content_entry";
+            page_surface: "page_surface";
+        }>;
+        nodeId: z.ZodString;
+    }, z.core.$strip>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>], "type">;
+/**
+ * TypeScript type for reload broadcast payloads.
+ * Derived from Zod schema for single source of truth.
+ */
+export type RealtimeReloadPayload = z.infer<typeof realtimeReloadPayloadSchema>;
+export type RealtimeLeaseChangedPayload = z.infer<typeof realtimeLeaseChangedPayloadSchema>;
+export type RealtimeSiteEvent = z.infer<typeof realtimeSiteEventSchema>;
+export declare function shouldReloadForClient(payload: RealtimeReloadPayload, view: Readonly<{
+    siteId: string;
+    resourceId?: string | null;
+    clientId?: string | null;
+}>): boolean;
+/**
+ * Get the Realtime channel name for a site's preview updates.
+ *
+ * @param siteId - UUID of the site
+ * @returns Channel name (format: "site:{siteId}:preview")
+ */
+export declare function getPreviewChannelName(siteId: string): string;
+/**
+ * Validate and parse a reload payload at the boundary.
+ *
+ * @param data - Unknown data to validate
+ * @returns Parsed and validated RealtimeReloadPayload
+ * @throws ZodError if validation fails
+ */
+export declare function validateReloadPayload(data: unknown): RealtimeReloadPayload;
+export declare function validateSiteEvent(data: unknown): RealtimeSiteEvent;
+/**
+ * Create a reload payload for broadcasting.
+ *
+ * @param options - Payload options
+ * @returns Valid RealtimeReloadPayload
+ */
+export declare function createReloadPayload(options: {
+    siteId: string;
+    resource: 'theme' | 'page' | 'content';
+    resourceId?: string;
+    origin?: string | null;
+}): RealtimeReloadPayload;
+export declare function createLeaseChangedPayload(options: {
+    siteId: string;
+    scope: RealtimeEditScope;
+}): RealtimeLeaseChangedPayload;

package/dist/_dts/realtime/src/useDraftChannel.d.ts

@@ -0,0 +1,34 @@
+import { type DraftChannelStatus, type DraftRealtimeClient, type DraftSendResult } from './draftChannel';
+import type { DraftStateMessage, DraftSyncRequestMessage } from './drafts';
+/**
+ * `token` with a null access token waits (does not join) until one arrives.
+ * Changing the token never rebuilds the channel while it is healthy; the new
+ * token is applied in place.
+ */
+export type UseDraftChannelAuth = Readonly<{
+    kind: 'session';
+}> | Readonly<{
+    kind: 'token';
+    accessToken: string | null;
+}>;
+export type UseDraftChannelOptions = Readonly<{
+    /** Must be referentially stable (e.g. a module-level or memoised client). */
+    client: DraftRealtimeClient | null;
+    siteId: string;
+    enabled?: boolean;
+    auth: UseDraftChannelAuth;
+    onDraftState?: (message: DraftStateMessage) => void;
+    onSyncRequest?: (message: DraftSyncRequestMessage) => void;
+}>;
+export type DraftChannelHookStatus = DraftChannelStatus | 'idle';
+export type DraftHookSendResult = DraftSendResult | 'not-connected';
+/**
+ * Join the private drafts channel for a site while mounted and enabled.
+ * Handlers are read through a ref, so re-renders never rejoin; only the client,
+ * site, enablement, auth mode or a needed rejoin after a token change do.
+ */
+export declare function useDraftChannel(options: UseDraftChannelOptions): {
+    status: DraftChannelHookStatus;
+    sendDraftState: (message: DraftStateMessage) => Promise<DraftHookSendResult>;
+    sendSyncRequest: (message: DraftSyncRequestMessage) => Promise<DraftHookSendResult>;
+};

package/dist/_dts/realtime/src/useSiteRealtimeReload.d.ts

@@ -0,0 +1,27 @@
+import { type RealtimeReloadPayload } from './types';
+export type RealtimeStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
+type ReloadChannel = Readonly<{
+    on: (event: 'broadcast', filter: {
+        event: 'reload' | 'lease-changed';
+    }, callback: (message: {
+        payload: unknown;
+    }) => void) => unknown;
+    subscribe: (callback: (status: string) => void) => unknown;
+    unsubscribe: () => unknown;
+}>;
+export type SiteRealtimeReloadOptions = Readonly<{
+    siteId: string;
+    resourceId?: string | null;
+    getClientId?: () => string | null;
+    enabled?: boolean;
+    createChannel: (name: string) => ReloadChannel;
+    onReload: (payload: RealtimeReloadPayload) => void;
+}>;
+export declare function useSiteRealtimeReload({ siteId, resourceId, getClientId, enabled, createChannel, onReload, }: SiteRealtimeReloadOptions): {
+    status: RealtimeStatus;
+    subscribeToLeaseChanges: (scope: {
+        nodeType: "page" | "content_entry" | "page_surface";
+        nodeId: string;
+    }, listener: () => void) => () => void;
+};
+export {};

package/dist/_dts/sdk/src/public-api/contracts.d.ts

@@ -1,6 +1,6 @@
 import type { AddressedLocationValue, BusinessAddress } from '../../../core/src/index';
 import type { ResolvedInternalLinkEntityType } from '../../../blocks/src/index';
-import type { APIEndpoints, PublicBookingService as ApiPublicBookingService, PublicBookingServiceCatalogueItem as ApiPublicBookingServiceCatalogueItem, PublicBookingServicesResponse as ApiPublicBookingServicesResponse, PublicServiceCategorySummary as ApiPublicServiceCategorySummary, RoutableContentItem as ApiRoutableContentItem, SdkRuntimePageSurfaceSubject as ApiSdkRuntimePageSurfaceSubject, SiteBySlugResponse as ApiSiteBySlugResponse, SiteBookingOfferingPresetSummary as ApiSiteBookingOfferingPresetSummary, SdkBlockContentAdmission } from '../../../api/src/index';
+import type { APIEndpoints, ApiErrorCode as SharedApiErrorCode, PublicBookingService as ApiPublicBookingService, PublicBookingServiceCatalogueItem as ApiPublicBookingServiceCatalogueItem, PublicBookingServicesResponse as ApiPublicBookingServicesResponse, PublicServiceCategorySummary as ApiPublicServiceCategorySummary, RoutableContentItem as ApiRoutableContentItem, SdkRuntimePageSurfaceSubject as ApiSdkRuntimePageSurfaceSubject, SdkRuntimePageSurfaceContentSource as ApiSdkRuntimePageSurfaceContentSource, SdkRuntimePageSurface as ApiSdkRuntimePageSurface, SdkRuntimeEntry as ApiSdkRuntimeEntry, SiteBySlugResponse as ApiSiteBySlugResponse, SiteBookingOfferingPresetSummary as ApiSiteBookingOfferingPresetSummary, SdkBlockContentAdmission } from '../../../api/src/index';
 import type { MediaAssetIndexItem, SiteFooterContent, SiteHeaderContent } from '../contracts';
 import type { PageRuntimeJoin } from '../../../theme-core/src/site-styles/index';
 import type { BlockFieldConfig as SdkBlockFieldConfig, BlockFieldOptionsMap as SdkBlockFieldOptionsMap, ContentConfig as SdkContentConfig, ContainerOptionsConfig as SdkContainerOptionsConfig, FieldSelectOption as SdkFieldSelectOption, SdkCustomBlock, SdkThemeConfig, SdkThemePalette, SectionBackground as SdkSectionBackground, SectionOptionsConfig as SdkSectionOptionsConfig, SiteStyleConfig as SdkSiteStyleConfig } from '../config/types';
@@ -33,7 +33,7 @@ export interface ApiResponse<TData> {
     data: TData;
     meta: ResponseMeta;
 }
-export type ApiErrorCode = 'auth:unauthenticated' | 'auth:token_expired' | 'auth:token_invalid' | 'auth:forbidden' | 'auth:mfa_required' | 'auth:sudo_required' | 'auth:insufficient_permissions' | 'auth:impersonation_restricted' | 'validation:invalid_input' | 'validation:missing_field' | 'validation:invalid_format' | 'validation:payload_too_large' | 'resource:not_found' | 'resource:already_exists' | 'resource:conflict' | 'resource:gone' | 'rate_limit:exceeded' | 'billing:payment_required' | 'billing:plan_limit_exceeded' | 'billing:pass_redemption_failed' | 'server:internal_error' | 'server:unavailable' | 'external:service_error' | 'external:registrar_orphaned_contact_profile' | 'network:connection_error' | 'network:timeout' | 'network:dns_error';
+export type ApiErrorCode = SharedApiErrorCode;
 export interface FieldError {
     field: string;
     code: string;
@@ -299,6 +299,7 @@ export type SiteRouteRecord = {
 export type SiteBookingOfferingPresetSummary = ApiSiteBookingOfferingPresetSummary;
 type SiteSelectionResponse = Pick<ApiSiteBySlugResponse, 'theme' | 'hostedBookingAppearance' | 'themeId' | 'bookingAttribution' | Extract<keyof ApiSiteBySlugResponse, `selection${string}`>>;
 export type SiteResponse = SiteSelectionResponse & {
+    demoEmailSuppressed?: boolean;
     site: ApiSiteBySlugResponse['site'] & {
         id: string;
         title: string;
@@ -414,36 +415,8 @@ export type SdkSurfaceSlotContent = {
     }>;
 };
 export type SdkRuntimePageSurfaceSubject = ApiSdkRuntimePageSurfaceSubject;
-export type SdkRuntimePageSurfaceContentSource = Readonly<{
-    kind: 'pageSurface';
-    contentTypeId: string;
-    contentTypeKey: string;
-    templateKey: string | null;
-}>;
-export type SdkRuntimePageSurface = {
-    id: string;
-    routeId: string;
-    readinessState: 'internal_pilot' | 'shippable';
-    subject: SdkRuntimePageSurfaceSubject;
-    title: string;
-    slug: string | null;
-    path: string | null;
-    status: string;
-    publishAt: string | null;
-    content: Record<string, unknown>;
-    draftContent: Record<string, unknown> | null;
-    publishedContent: Record<string, unknown> | null;
-    metaTitle: string | null;
-    draftMetaTitle: string | null;
-    metaDescription: string | null;
-    draftMetaDescription: string | null;
-    ogImageId: string | null;
-    ogImageUrl: string | null;
-    canonicalUrl: string | null;
-    createdAt: string;
-    updatedAt: string;
-    contentSource: SdkRuntimePageSurfaceContentSource;
-};
+export type SdkRuntimePageSurfaceContentSource = ApiSdkRuntimePageSurfaceContentSource;
+export type SdkRuntimePageSurface = ApiSdkRuntimePageSurface;
 export type PageResponse = {
     page: SdkRuntimePage;
     templates?: SdkTemplate[];
@@ -465,29 +438,7 @@ export type PageResponse = {
     type: 'pageSurface';
 };
 export type SdkRuntimeMediaAsset = MediaAssetIndexItem;
-export type SdkRuntimeEntry = {
-    id: string;
-    routeId: string | null;
-    type: string | null;
-    title: string;
-    slug: string | null;
-    status: string;
-    publishAt: string | null;
-    path: string | null;
-    draftPath: string | null;
-    content: Record<string, unknown>;
-    draftContent: Record<string, unknown> | null;
-    publishedContent: Record<string, unknown> | null;
-    metaTitle: string | null;
-    draftMetaTitle: string | null;
-    metaDescription: string | null;
-    draftMetaDescription: string | null;
-    ogImageId: string | null;
-    ogImageUrl: string | null;
-    canonicalUrl: string | null;
-    createdAt: string;
-    updatedAt: string;
-};
+export type SdkRuntimeEntry = ApiSdkRuntimeEntry;
 export type PublishedContentEntryPreview = {
     id: string;
     title: string;

package/dist/_dts/sdk/src/rendering/blocks-page-renderer.d.ts

@@ -20,6 +20,7 @@ type MissingBlockOverrideErrorConstructor = Readonly<{
 export declare const MissingBlockOverrideError: MissingBlockOverrideErrorConstructor;
 export type PageRendererDataContext = {
     siteId?: string;
+    demoEmailSuppressed?: boolean;
     siteName?: string;
     pageId?: string;
     /** Canonical request pathname used by blocks when resolving same-site destinations. */

package/dist/_dts/sdk/src/rendering/components/pageShared.d.ts

@@ -62,6 +62,7 @@ type PageCommonProps = {
      */
     dataContext: {
         readAuthority?: import('../../../../blocks/src/api').BrowserReadAuthority;
+        demoEmailSuppressed?: boolean;
         siteName?: string;
         /** Mailing-list runtime projected for the placements on this page. */
         mailingList?: import('../../../../core/src/index').MailingListRuntimeContext;

package/dist/_dts/sdk/src/rendering/helpers/pageRuntimeSupport.d.ts

@@ -44,6 +44,8 @@ type TransportedPageBlock = PageOutline['blocks'][number] & Readonly<{
     draftContentId: string | null;
     publishedPlacement: PublishedBlockPlacementRead;
 }>;
+/** Pair SDK preview publication data whether it is transported or already admitted. */
+export declare function readSdkPreviewPublishedPlacement(block: Record<string, unknown>, kind: string): PublishedBlockPlacementRead;
 export declare function readInvalidBlockAdmission(value: unknown): Readonly<{
     kind: 'invalid';
     error: PageBlockRenderAdmissionError;

package/dist/_dts/sdk/src/rendering/islands/types.d.ts

@@ -1,6 +1,6 @@
 import type { ButtonVariant as SystemButtonVariant, EventScheduleScope as SystemEventScheduleScope, EventSurfacePreset as SystemEventSurfacePreset, RichTextDoc as SystemRichTextDoc } from '../../contracts/system-block-content';
 import type { PublicTeamMemberSummary } from '../../../../api/src/index';
-import type { BookingFlexibleBalanceConfig, BookingInstalmentPlanConfig, LocationCoordinates, PublicEventPriceDisplay, PublicEventPricing, PublicEventPricingOption, PublicEventPricingOptionAvailability, PublicEventPricingType } from '../../../../core/src/index';
+import type { BookingPaymentCollectionOption, LocationCoordinates, PublicEventPriceDisplay, PublicEventPricing, PublicEventPricingOption, PublicEventPricingOptionAvailability, PublicEventPricingType } from '../../../../core/src/index';
 import type { AccordionIslandProps as BlocksAccordionIslandProps, BookingFormConfig as BlocksBookingFormConfig, BookingFormInteractiveIslandProps as BlocksBookingFormIslandProps, BookingFormService as BlocksBookingFormService, CarouselIslandProps as BlocksCarouselIslandProps, CartDisplay as BlocksCartDisplay, CartInteractiveIslandProps as BlocksCartIslandProps, CartLineDisplay as BlocksCartLineDisplay, CheckoutDisplay as BlocksCheckoutDisplay, CheckoutInteractiveIslandProps as BlocksCheckoutIslandProps, EventCalendarInteractiveIslandProps as BlocksEventCalendarIslandProps, EventCombinedInteractiveIslandProps as BlocksEventCombinedIslandProps, EventDetailsIslandProps as BlocksEventDetailsIslandProps, EventDetailsOccurrenceContext as BlocksEventDetailsOccurrenceContext, LocationMapIslandProps as BlocksLocationMapIslandProps, EventRegistrationInteractiveIslandProps as BlocksEventRegistrationIslandProps, EventListingDisplay as BlocksEventListingDisplay, EventListingHydration as BlocksEventListingHydration, EventListingInteractiveIslandProps as BlocksEventListingIslandProps, PublicEvent as BlocksPublicEvent, FormInteractiveIslandProps as BlocksFormIslandProps, HeaderSectionIslandProps as BlocksHeaderSectionIslandProps, MembershipCardDisplay as BlocksMembershipCardDisplay, NewsletterFormInteractiveIslandProps as BlocksNewsletterFormIslandProps, PassCardDisplay as BlocksPassCardDisplay, PassesMembershipsDisplay as BlocksPassesMembershipsDisplay, ProductCardDisplay as BlocksProductCardDisplay, ProductDetailDisplay as BlocksProductDetailDisplay, ProductDetailInteractiveIslandProps as BlocksProductDetailIslandProps, ProductListDisplay as BlocksProductListDisplay, ProductListInteractiveIslandProps as BlocksProductListIslandProps, ProductVariantOptionDisplay as BlocksProductVariantOptionDisplay, ShopInteractiveIslandProps as BlocksShopIslandProps } from '../../../../blocks/src/contracts/index';
 export type ResponsiveSlidesToShow = {
     mobile?: number | string;
@@ -72,17 +72,7 @@ export type PublicEventAttendanceModeAvailability = {
     waitlistEnabled: boolean;
 };
 export type { PublicTeamMemberSummary };
-export type BookingPaymentCollectionOption = {
-    kind: 'upfront';
-} | {
-    kind: 'deferred_manual';
-} | {
-    kind: 'instalment_plan';
-    plan: BookingInstalmentPlanConfig;
-} | {
-    kind: 'flexible_balance';
-    config: BookingFlexibleBalanceConfig;
-};
+export type { BookingPaymentCollectionOption };
 export type BookingPaymentTerms = {
     allowedOptions: BookingPaymentCollectionOption[];
 };

package/dist/_dts/sdk/src/version.d.ts

@@ -8,4 +8,4 @@
  * 1. This constant
  * 2. The "version" field in package.json
  */
-export declare const SDK_VERSION = "0.147.0";
+export declare const SDK_VERSION = "0.149.0";

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

@@ -35,6 +35,7 @@ export type SurfaceHostContext = Readonly<{
  */
 export declare const SURFACE_ROOT_HOSTS: Readonly<Record<SurfaceId, Readonly<Record<SurfaceTier, string>>>>;
 export declare const SURFACE_SITE_ROOT_HOSTS: Readonly<Record<SurfaceId, Readonly<Record<SurfaceTier, string>>>>;
+export declare const SURFACE_SITE_ROOT_HOST_ALIASES: Readonly<Partial<Record<SurfaceId, Readonly<Partial<Record<SurfaceTier, readonly string[]>>>>>>;
 /**
  * Site slugs a surface host already occupies. A site's managed address is
  * `{slug}.{site root host}`, so any surface host (dashboard root, site root or