@riverbankcms/sdk 0.135.0 → 0.136.0

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

@@ -8,6 +8,8 @@ import type { RouteMap } from './system/transforms';
 import { type MediaAssetIndexItem, type ResolveImageUrlContext, type ResolveImageUrlContextInput } from './system/runtime/nodes/media';
 import type { BookingOfferingPresetSummary } from './system/blocks/offerings-preview/model';
 import { type PageBoundaryWrapper, type PageRuntimeBoundary } from './pageRendererBoundaries';
+import { type RenderablePageOutline } from './pageRenderAdmission';
+export type { PageBlockRenderAdmissionError, RenderablePageBlock, RenderablePageOutline, } from './pageRenderAdmission';
 export { MissingBlockOverrideError } from './pageRenderingMode';
 export type { PageBlockPosition, PageRuntimeBoundary, } from './pageRendererBoundaries';
 /**
@@ -40,6 +42,7 @@ type PageRendererDataContext = {
     apiBaseUrl?: string;
     portalToken?: string | null;
     bookingOfferingPresets?: readonly BookingOfferingPresetSummary[];
+    bookingTimeZone?: string;
     eventRegistrationOverlayEnabled?: boolean;
 };
 /**
@@ -75,6 +78,8 @@ export type BlockOverrideProps<TContent = Record<string, unknown>> = {
     siteId?: string;
     /** Dashboard API URL for client-side block runtime calls. */
     apiBaseUrl?: string;
+    /** Canonical site timezone for calendar/date behavior. */
+    bookingTimeZone?: string;
     /** Customer portal token for Bearer-authenticated block runtime calls. */
     portalToken?: string | null;
     /** Preview bearer token for preview-aware block runtime calls. */
@@ -146,10 +151,9 @@ export type BlockOverrides = Record<string, BlockOverrideComponent>;
 export type SdkConfigForRenderer = {
     customBlocks?: SdkCustomBlock[];
 };
-type PageRendererCommonProps = {
-    page: PageOutline | null;
+type PageRendererCommonProps<TPage> = {
+    page: TPage | null;
     runtimeBoundaries?: readonly PageRuntimeBoundary[];
-    usePlaceholders?: boolean;
     dataContext?: PageRendererDataContext;
     routeMap?: RouteMap;
     wrapBlock?: (blockId: string, rendered: React.ReactNode) => React.ReactNode;
@@ -160,12 +164,12 @@ type PageRendererCommonProps = {
     customBlocks?: SdkCustomBlock[];
     previewAuthoring?: ResolverContext['previewAuthoring'];
 };
-type ThemedPageRendererProps = PageRendererCommonProps & {
+type ThemedPageRendererProps<TPage> = PageRendererCommonProps<TPage> & {
     rendering?: never;
     theme: Theme;
     themeTokens?: ThemeTokens;
 };
-type OverrideOnlyPageRendererProps = PageRendererCommonProps & {
+type OverrideOnlyPageRendererProps<TPage> = PageRendererCommonProps<TPage> & {
     rendering: {
         kind: 'overrides-only';
     };
@@ -173,5 +177,7 @@ type OverrideOnlyPageRendererProps = PageRendererCommonProps & {
     themeTokens?: never;
     blockOverrides: BlockOverrides;
 };
-export type PageRendererProps = ThemedPageRendererProps | OverrideOnlyPageRendererProps;
+export type PageRendererProps = ThemedPageRendererProps<RenderablePageOutline> | OverrideOnlyPageRendererProps<RenderablePageOutline>;
+export type EditorPageRendererProps = ThemedPageRendererProps<PageOutline> | OverrideOnlyPageRendererProps<PageOutline>;
 export default function PageRenderer(props: PageRendererProps): React.JSX.Element;
+export declare function EditorPageRenderer(props: EditorPageRendererProps): React.JSX.Element;

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

@@ -365,6 +365,14 @@ export declare const proofBlockIslandCodecs: {
                     eventSurface: import("..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>>;
         }>) => unknown;
@@ -385,6 +393,14 @@ export declare const proofBlockIslandCodecs: {
                     eventSurface: import("..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>>;
         }>>;
@@ -871,6 +887,14 @@ export declare const runtimeIslandCodecs: {
                     eventSurface: import("..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>>;
         }>) => unknown;
@@ -891,6 +915,14 @@ export declare const runtimeIslandCodecs: {
                     eventSurface: import("..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>>;
         }>>;
@@ -1251,6 +1283,14 @@ export declare const runtimeIslandCodecs: {
                     eventSurface: import("..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>>;
         }>) => unknown;
@@ -1271,6 +1311,14 @@ export declare const runtimeIslandCodecs: {
                     eventSurface: import("..").EventSurfaceScope;
                     filterEventPresets: string | null;
                     scheduleScope: import("..").EventScheduleScope;
+                    calendarContext: Readonly<{
+                        timeZone: import("../../../core/src/index").BookingTimeZone;
+                        initialToday: Readonly<{
+                            year: number;
+                            month: number;
+                            day: number;
+                        }>;
+                    }>;
                 }>;
             }>>;
         }>>;

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

@@ -0,0 +1,14 @@
+/**
+ * Pure server-safe definitions for Builder blocks.
+ * This entry point MUST NOT import any React components or client-side code.
+ * It is safe to use in Server Components and data fetching utilities.
+ */
+export { getBlockDefinition, getBlockRenderKind, listBlockDefinitions, hasBlockDefinition, registerBlockDefinition, type SystemBlockDefinition, type BlockDataLoader, type BlockDescriptor, } from './system/registry';
+export { blockDesignCapabilityMapFromDefinitions, blockDesignMetadataMapFromDefinitions, declareBlockDesignCapability, declareNoBlockDesignCapability, resolveDeclaredBlockDesignCapability, } from './system/designCapabilities';
+export type { BlockDesignCapabilityDeclaration, NoBlockDesignCapabilityReason, } from './system/designCapabilities';
+export type { AnyBlockRuntimeDefinition, BlockRenderKind, BlockRuntimeDefinition, RuntimeContractsFor, RuntimeDisplay, RuntimeHydration, RuntimeKind, RuntimeRender, RuntimeSource, } from './contracts';
+export { ensureSystemBlockDefinitionsRegistered, systemBlockDefinitions, } from './system/blocks';
+export { resolveVariantKey as resolveBlockVariantKey } from './system/manifest/variantKey';
+export type { SystemBlockKind, } from './system/blocks';
+export * from './system/data';
+export type { PageOutline, Block } from './structure/schema';

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

@@ -1,7 +1,7 @@
-export { default as PageRenderer } from './PageRenderer';
+export { default as PageRenderer, EditorPageRenderer } from './PageRenderer';
 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, PageRendererProps, OccurrenceContextData, PageBlockPosition, PageRuntimeBoundary, SdkConfigForRenderer, } from './PageRenderer';
+export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, EditorPageRendererProps, PageBlockRenderAdmissionError, PageRendererProps, RenderablePageBlock, RenderablePageOutline, OccurrenceContextData, PageBlockPosition, PageRuntimeBoundary, SdkConfigForRenderer, } from './PageRenderer';
 export { MissingBlockOverrideError } from './pageRenderingMode';
 export * from './subroutes';
 export * from './structure/schema';
@@ -47,7 +47,8 @@ export { createRichTextDocFromMarkdown, parseRichTextInlineMarkdown, parseRichTe
 export { applyInlineTextMarkToRange, coerceInlineTextWithFallback, inlineTextEqual, inlineTextAccentTones, inlineTextHighlightTones, inlineTextMarksEqual, inlineTextSchema, inlineTextToPlainText, isInlineTextEmpty, normalizeInlineText, normalizeInlineTextMarks, parseInlineTextFromUnknown, plainTextToInlineText, removeInlineTextMarkFromRange, replaceInlineTextRange, truncateInlineText, type InlineText, type InlineTextAccentTone, type InlineTextHighlightTone, type InlineTextMark, type InlineTextParseError, type InlineTextParseResult, type InlineTextRun, } from './system/inlineText';
 export { renderInlineText } from './system/runtime/nodes/renderInlineText';
 export type { RichTextDoc, RichTextHardBreakNode, RichTextInlineNode, RichTextTextNode, TipTapNode, } from './system/manifest/richTextSchema';
-export { createManifestValidator, createManifestWriteValidator, } from './system/manifest/validation';
+export { admitManifestContentForWrite, admitStoredManifestContent, admitTransportedRenderableManifestContent, compileManifestContentContract, deriveContentZodFromManifest, deriveRenderableManifestContent, findNonPortableManifestMediaPaths, resolveManifestContentFieldDescriptor, validateManifestDraft, validateManifestWriteCandidate, } from './system/manifest/validation';
+export type { CompiledManifestContentContract, ManifestContentAdmissionError, ManifestContentAdmissionIssue, ManifestContentAdmissionResult, ManifestDraftValidationResult, ManifestWriteCandidateValidationResult, RenderableManifestContent, StoredManifestContent, } from './system/manifest/validation';
 export { singleButtonManifest } from './system/blocks/single-button';
 export { Text, RichText } from './primitives/content/primitives';
 export type { PrimitiveAPI, RichTextPrimitiveProps, RichTextVariant, TextProps, } from './primitives/content/primitives';

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

@@ -0,0 +1,40 @@
+import type { Block, PageOutline } from './structure/schema';
+import type { ManifestContentAdmissionError, RenderableManifestContent } from './system/manifest/validation';
+export type PageBlockRenderAdmissionError = Readonly<{
+    kind: 'invalid_manifest_content';
+    error: ManifestContentAdmissionError;
+}> | Readonly<{
+    kind: 'manifest_unavailable';
+}>;
+export type RenderablePageBlock = Readonly<{
+    id: Block['id'];
+    kind: Block['kind'];
+    purpose: Block['purpose'];
+    bindings?: Block['bindings'];
+    admission: Readonly<{
+        kind: 'renderable';
+        content: RenderableManifestContent;
+    }> | Readonly<{
+        kind: 'invalid';
+        error: PageBlockRenderAdmissionError;
+    }>;
+}>;
+export type RenderablePageOutline = Omit<PageOutline, 'blocks'> & Readonly<{
+    blocks: readonly RenderablePageBlock[];
+}>;
+export type PresentationAdmission = Readonly<{
+    kind: 'renderable';
+}> | Readonly<{
+    kind: 'editor';
+}> | Readonly<{
+    kind: 'invalid';
+    error: PageBlockRenderAdmissionError;
+}>;
+export type PresentationBlock = Block & Readonly<{
+    presentationAdmission: PresentationAdmission;
+}>;
+export type PresentationPageOutline = Omit<PageOutline, 'blocks'> & Readonly<{
+    blocks: readonly PresentationBlock[];
+}>;
+export declare function toPresentationPage(page: RenderablePageOutline | null): PresentationPageOutline | null;
+export declare function toEditorPresentationPage(page: PageOutline | null): PresentationPageOutline | null;

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

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

package/dist/_dts/blocks/src/system/blocks/events/shared/schemas.d.ts

@@ -93,6 +93,11 @@ export declare const publicWholeSeriesPriceDisplaySchema: z.ZodDiscriminatedUnio
     kind: z.ZodLiteral<"from">;
     amount: z.ZodNumber;
     currency: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"range">;
+    minAmount: z.ZodNumber;
+    maxAmount: z.ZodNumber;
+    currency: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"unavailable">;
     currency: z.ZodString;
@@ -137,6 +142,11 @@ export declare const publicEventPriceDisplaySchema: z.ZodDiscriminatedUnion<[z.Z
         kind: z.ZodLiteral<"from">;
         amount: z.ZodNumber;
         currency: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"range">;
+        minAmount: z.ZodNumber;
+        maxAmount: z.ZodNumber;
+        currency: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"unavailable">;
         currency: z.ZodString;
@@ -349,6 +359,11 @@ export declare const publicEventPricingSchema: z.ZodDiscriminatedUnion<[z.ZodObj
             kind: z.ZodLiteral<"from">;
             amount: z.ZodNumber;
             currency: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"range">;
+            minAmount: z.ZodNumber;
+            maxAmount: z.ZodNumber;
+            currency: z.ZodString;
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"unavailable">;
             currency: z.ZodString;
@@ -896,6 +911,11 @@ export declare const publicEventSchema: z.ZodObject<{
                 kind: z.ZodLiteral<"from">;
                 amount: z.ZodNumber;
                 currency: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"range">;
+                minAmount: z.ZodNumber;
+                maxAmount: z.ZodNumber;
+                currency: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"unavailable">;
                 currency: z.ZodString;
@@ -1600,6 +1620,11 @@ export declare const publicEventsArraySchema: z.ZodArray<z.ZodObject<{
                 kind: z.ZodLiteral<"from">;
                 amount: z.ZodNumber;
                 currency: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"range">;
+                minAmount: z.ZodNumber;
+                maxAmount: z.ZodNumber;
+                currency: z.ZodString;
             }, z.core.$strip>, z.ZodObject<{
                 kind: z.ZodLiteral<"unavailable">;
                 currency: z.ZodString;

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

@@ -10,6 +10,8 @@ export { initialPreviewResolvedDataState, previewResolvedDataReducer, selectPrev
 export type { PreviewLoaderError, PreviewResolvedDataAction, PreviewResolvedDataState, } from './previewResolvedDataState';
 export { SUPPORTED_LOADER_ENDPOINTS, isSupportedLoaderEndpoint, } from './loaderEndpoints';
 export type { SupportedLoaderEndpoint } from './loaderEndpoints';
+export { PUBLIC_LOADER_CACHE_POLICIES, getPublicLoaderCachePolicy, } from './publicLoaderCachePolicy';
+export type { PublicLoaderCachePolicy, PublicLoaderCacheTagKind, } from './publicLoaderCachePolicy';
 export { createMicrobatcher, stableSerialize, type BatchItemResult, type Microbatcher, } from './batching';
 export { normalizeLoaderParams, normalizePublicApiLoaderParams, } from './normalizeLoaderParams';
 export { normalizeDataLoaders, normalizeContent, normalizeParams, coerceToString, coercePayload, } from './utils';

package/dist/_dts/blocks/src/system/data/publicLoaderCachePolicy.d.ts

@@ -0,0 +1,78 @@
+import type { SupportedLoaderEndpoint } from './loaderEndpoints';
+export type PublicLoaderCacheTagKind = 'published_content' | 'public_whole_series_offerings' | 'public_team_members' | 'public_products' | 'site_forms';
+export type PublicLoaderCachePolicy = Readonly<{
+    kind: 'live';
+    reason: 'booking_correctness';
+}> | Readonly<{
+    kind: 'tagged';
+    tags: readonly PublicLoaderCacheTagKind[];
+}>;
+/**
+ * Canonical freshness policy for public block-loader data.
+ *
+ * Consumers may implement tagged caching differently, but a loader marked
+ * live here must not be placed in a process-local or durable stale cache.
+ */
+export declare const PUBLIC_LOADER_CACHE_POLICIES: {
+    readonly listPublishedEntries: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["published_content"];
+    };
+    readonly getPublishedEntryPreview: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["published_content"];
+    };
+    readonly listPublicEvents: {
+        readonly kind: "live";
+        readonly reason: "booking_correctness";
+    };
+    readonly listPublicRecurringSchedule: {
+        readonly kind: "live";
+        readonly reason: "booking_correctness";
+    };
+    readonly getPublicEventDetails: {
+        readonly kind: "live";
+        readonly reason: "booking_correctness";
+    };
+    readonly listPublicWholeSeriesOfferings: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["public_whole_series_offerings"];
+    };
+    readonly getPublicWholeSeriesOffering: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["public_whole_series_offerings"];
+    };
+    readonly listPublicRouteCandidates: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["published_content"];
+    };
+    readonly listPublicTeamMembers: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["public_team_members"];
+    };
+    readonly listPublicProducts: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["public_products"];
+    };
+    readonly listPublicPasses: {
+        readonly kind: "live";
+        readonly reason: "booking_correctness";
+    };
+    readonly listPublicMemberships: {
+        readonly kind: "live";
+        readonly reason: "booking_correctness";
+    };
+    readonly getPublicFormById: {
+        readonly kind: "tagged";
+        readonly tags: readonly ["site_forms"];
+    };
+    readonly getPublicBookingServices: {
+        readonly kind: "live";
+        readonly reason: "booking_correctness";
+    };
+    readonly getPublicWeeklySlotAvailability: {
+        readonly kind: "live";
+        readonly reason: "booking_correctness";
+    };
+};
+export declare function getPublicLoaderCachePolicy(endpoint: SupportedLoaderEndpoint): PublicLoaderCachePolicy;

package/dist/_dts/blocks/src/system/manifest/fieldValidation/index.d.ts

@@ -143,21 +143,6 @@ type BaseIssue<K extends string, Extra extends object = Record<never, never>> =
     fieldId: string;
     label: string;
 }> & Readonly<Extra>;
-export type ManifestContentRequiredScope = "topLevel" | "nested";
-export type ManifestContentValidationIssue = Readonly<{
-    kind: FieldValidationIssue["kind"];
-    field: string;
-    message: string;
-    requiredScope: ManifestContentRequiredScope | null;
-}>;
-export type ManifestContentValidationResult = Readonly<{
-    kind: 'valid';
-    issues: readonly [];
-    data: Readonly<Record<string, unknown>>;
-}> | Readonly<{
-    kind: "invalid";
-    issues: readonly ManifestContentValidationIssue[];
-}>;
 type PlanBase<K extends string, ValueKind extends string, Constraints extends FieldConstraint> = Readonly<{
     kind: K;
     valueKind: ValueKind;
@@ -265,11 +250,10 @@ export declare function validateFieldValue(plan: FieldValidationPlan, value: unk
 export declare function fieldPlanToZod(plan: FieldValidationPlan, options?: FieldValidationOptions): z.ZodTypeAny;
 export declare function fieldPresenceForPlan(plan: Pick<FieldValidationPlan, "required">): FieldPresence;
 export declare function fieldPlanToObjectPropertyZod(plan: FieldValidationPlan, options?: FieldValidationOptions): z.ZodTypeAny;
+/** Validate stored field values without applying editor/write normalization. */
+export declare function fieldPlanToStoredObjectPropertyZod(plan: FieldValidationPlan): z.ZodTypeAny;
 export declare function resolveFieldValidationDescriptor(plans: readonly FieldValidationPlan[], path: FieldPath): FieldValidationDescriptor | null;
 export declare function validateManifestValues(fields: readonly FieldDefinition[], values: Record<string, unknown>, options?: FieldValidationOptions): FieldValidationIssue[];
-export declare function validateManifestContentForPush(fields: readonly FieldDefinition[], values: Record<string, unknown>, options?: FieldValidationOptions): ManifestContentValidationResult;
-export declare function isTopLevelRequiredManifestContentIssue(issue: ManifestContentValidationIssue): boolean;
-export declare function formatManifestContentValidationIssue(issue: ManifestContentValidationIssue): string;
 export declare function isCanonicalEmailValue(value: string): boolean;
 export declare function isCanonicalPhoneValue(value: string): boolean;
 export declare function isCanonicalUrlValue(value: string, options?: Readonly<{

package/dist/_dts/blocks/src/system/manifest/validation.d.ts

@@ -1,6 +1,69 @@
-import { z } from "zod";
-import type { BlockManifest, FieldDefinition } from "./schema";
+import { z } from 'zod';
+import type { BlockManifest, FieldDefinition } from './schema';
+import { type FieldValidationDescriptor, type FieldValidationPlan } from './fieldValidation';
 type FieldShape = Record<string, z.ZodTypeAny>;
+declare const manifestContentStage: unique symbol;
+declare const compiledManifestContentContract: unique symbol;
+type CompiledManifestContentContractState = Readonly<{
+    plans: readonly FieldValidationPlan[];
+    strictStoredSchema: z.ZodType<Record<string, unknown>>;
+    writeSchema: z.ZodType<Record<string, unknown>>;
+    draftSchema: z.ZodType<Record<string, unknown>>;
+    renderSchema: z.ZodType<Record<string, unknown>>;
+    findNonPortableMediaPaths: (content: unknown) => readonly string[];
+}>;
+export type CompiledManifestContentContract = Readonly<{
+    [compiledManifestContentContract]: CompiledManifestContentContractState;
+}>;
+export type StoredManifestContent = Readonly<Record<string, unknown>> & Readonly<{
+    [manifestContentStage]: 'stored';
+}>;
+export type RenderableManifestContent = Readonly<Record<string, unknown>> & Readonly<{
+    [manifestContentStage]: 'renderable';
+}>;
+export type ManifestContentAdmissionIssue = Readonly<{
+    code: z.core.$ZodIssue['code'];
+    path: readonly (string | number)[];
+    message: string;
+}>;
+export type ManifestContentAdmissionError = Readonly<{
+    kind: 'invalid_shape';
+    issues: readonly ManifestContentAdmissionIssue[];
+}> | Readonly<{
+    kind: 'non_portable_media';
+    paths: readonly string[];
+}>;
+export type ManifestContentAdmissionResult<T> = Readonly<{
+    ok: true;
+    value: T;
+}> | Readonly<{
+    ok: false;
+    error: ManifestContentAdmissionError;
+}>;
+export type ManifestDraftValidationResult = Readonly<{
+    kind: 'previewable';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [];
+}> | Readonly<{
+    kind: 'invalid';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [
+        ManifestContentAdmissionIssue,
+        ...ManifestContentAdmissionIssue[]
+    ];
+}>;
+export type ManifestWriteCandidateValidationResult = Readonly<{
+    kind: 'valid';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [];
+}> | Readonly<{
+    kind: 'invalid';
+    data: Readonly<Record<string, unknown>>;
+    issues: readonly [
+        ManifestContentAdmissionIssue,
+        ...ManifestContentAdmissionIssue[]
+    ];
+}>;
 type ValidatorOptions = {
     allowNull?: boolean;
     /**
@@ -8,22 +71,46 @@ type ValidatorOptions = {
      * Use for autosave scenarios where content may be incomplete.
      */
     allowIncomplete?: boolean;
-    /**
-     * Validation mode:
-     * - 'strict' (default): Enforce all required field constraints
-     * - 'draft': Preprocess empty values to undefined, use allowIncomplete for lenient validation
-     *
-     * Use 'draft' mode in preview/editing contexts where users need to temporarily
-     * have empty fields without validation errors causing blocks to disappear.
-     */
-    mode?: "strict" | "draft";
 };
 export declare function deriveContentZodFromManifest(manifestOrFields: BlockManifest | FieldDefinition[], options?: ValidatorOptions): z.ZodObject<FieldShape>;
-export declare function createManifestValidator(manifestOrFields: BlockManifest | FieldDefinition[], options?: ValidatorOptions): z.ZodType<Record<string, unknown>>;
 /**
- * Validates content at a persistence boundary and returns identifier-only media
- * values. Render-time validation intentionally uses createManifestValidator so
- * hydrated projection fields remain available to renderers.
+ * Compiles editor-facing manifest structure into the presentation-independent
+ * validation contract used by every manifest-content trust transition.
+ */
+export declare function compileManifestContentContract(manifestOrFields: BlockManifest | FieldDefinition[]): CompiledManifestContentContract;
+export declare function resolveManifestContentFieldDescriptor(contract: CompiledManifestContentContract, path: readonly (string | number)[]): FieldValidationDescriptor | null;
+/**
+ * Reports declared media fields carrying environment-specific keys.
+ *
+ * Split out of stored admission for callers that must prove portability of
+ * content whose *shape* is legitimately incomplete — a template block's stored
+ * defaults, for instance, where required values only arrive through entry
+ * bindings. Returns the offending paths, empty when the content is portable.
+ */
+export declare function findNonPortableManifestMediaPaths(contract: CompiledManifestContentContract, content: unknown): readonly string[];
+/** Strictly admits already-persisted content without repairing it. */
+export declare function admitStoredManifestContent(contract: CompiledManifestContentContract, content: unknown): ManifestContentAdmissionResult<StoredManifestContent>;
+/**
+ * Admits an effectfully resolved write candidate and canonicalizes declared
+ * media to its portable identifier-only representation.
+ */
+export declare function admitManifestContentForWrite(contract: CompiledManifestContentContract, content: unknown): ManifestContentAdmissionResult<StoredManifestContent>;
+/** Validates raw editor state without granting a stored-content proof. */
+export declare function validateManifestDraft(contract: CompiledManifestContentContract, data: Readonly<Record<string, unknown>>): ManifestDraftValidationResult;
+/**
+ * Checks whether a raw editor candidate is schema-ready for the effectful
+ * media-resolution/write boundary without granting a stored proof.
+ */
+export declare function validateManifestWriteCandidate(contract: CompiledManifestContentContract, data: Readonly<Record<string, unknown>>): ManifestWriteCandidateValidationResult;
+/**
+ * Applies a pure runtime projection to admitted stored content and validates
+ * the resulting render shape before granting the renderable proof.
+ */
+export declare function deriveRenderableManifestContent(contract: CompiledManifestContentContract, stored: StoredManifestContent, project: (content: StoredManifestContent) => Readonly<Record<string, unknown>>): ManifestContentAdmissionResult<RenderableManifestContent>;
+/**
+ * Re-admits renderable content after a transport boundary has erased its
+ * compile-time proof. Unlike write admission, this never canonicalizes or
+ * grants a stored proof, so hydrated media cannot flow back to persistence.
  */
-export declare function createManifestWriteValidator(manifestOrFields: BlockManifest | FieldDefinition[], options?: ValidatorOptions): z.ZodType<Record<string, unknown>>;
+export declare function admitTransportedRenderableManifestContent(contract: CompiledManifestContentContract, content: unknown): ManifestContentAdmissionResult<RenderableManifestContent>;
 export {};

package/dist/_dts/blocks/src/system/node/validation-constants.d.ts

@@ -20,7 +20,7 @@ export type AllowedNodeType = (typeof ALLOWED_NODE_TYPES)[number];
  * $bind.transforms within custom block layouts. Transform IDs
  * not in this list will be rejected during validation.
  */
-export declare const ALLOWED_TRANSFORM_IDS: readonly ["string.uppercase", "value.fallback", "date.formatShort", "array.length", "value.jsonArray", "value.csv", "array.marqueeLoop", "value.mapToken", "layout.maxWidthClass", "layout.headerRootClass", "layout.footerRootClass", "layout.headerRootStyle", "layout.headerSectionBackground", "layout.classicNavMode", "layout.footerRootStyle", "ui.headerNavLinkClass", "ui.headingClassFromAlignment", "ui.bodyClassFromAlignment", "ui.stackAlignFromAlignment", "ui.sectionStateTone", "ui.heroContentWrapperClass", "ui.heroCtaJustify", "ui.heroStackJustifyFromVerticalAlignment", "ui.heroGridClassFromVerticalAlignment", "ui.conditionalClass", "ui.twoColumnContainerClass", "ui.twoColumnFlexBasis", "ui.imageGalleryFilterClass", "ui.imageGalleryTileClass", "ui.imageGalleryTileStyle", "ui.imageGalleryMarqueeTileStyle", "ui.imageGalleryMarqueeDuration", "ui.imageGalleryMarqueeDirection", "ui.imageFragmentClass", "ui.imageFragmentSize", "media.fromUrl", "background.resolveStyle", "background.resolveColorsStyle", "background.resolveFrameClassName", "background.resolveImageStyle", "background.resolveImageClassName", "background.resolveOverlayStyle", "links.resolve", "links.label", "content.interpolateRichTextTokens", "boxStyles.spacing", "boxStyles.resolveRootClass", "boxStyles.resolveRootStyle", "boxStyles.semanticGap", "boxStyles.semanticGapValue", "containerStyles.resolveBoxClassName"];
+export declare const ALLOWED_TRANSFORM_IDS: readonly ["string.uppercase", "value.fallback", "date.formatShort", "array.length", "value.jsonArray", "value.csv", "array.marqueeLoop", "value.mapToken", "layout.maxWidthClass", "layout.headerRootClass", "layout.footerRootClass", "layout.headerRootStyle", "layout.headerSectionBackground", "layout.footerRootStyle", "ui.headerNavLinkClass", "ui.headingClassFromAlignment", "ui.bodyClassFromAlignment", "ui.stackAlignFromAlignment", "ui.sectionStateTone", "ui.heroContentWrapperClass", "ui.heroCtaJustify", "ui.heroStackJustifyFromVerticalAlignment", "ui.heroGridClassFromVerticalAlignment", "ui.conditionalClass", "ui.twoColumnContainerClass", "ui.twoColumnFlexBasis", "ui.imageGalleryFilterClass", "ui.imageGalleryTileClass", "ui.imageGalleryTileStyle", "ui.imageGalleryMarqueeTileStyle", "ui.imageGalleryMarqueeDuration", "ui.imageGalleryMarqueeDirection", "ui.imageFragmentClass", "ui.imageFragmentSize", "media.fromUrl", "background.resolveStyle", "background.resolveColorsStyle", "background.resolveFrameClassName", "background.resolveImageStyle", "background.resolveImageClassName", "background.resolveOverlayStyle", "links.resolve", "links.label", "content.interpolateRichTextTokens", "boxStyles.spacing", "boxStyles.resolveRootClass", "boxStyles.resolveRootStyle", "boxStyles.semanticGap", "boxStyles.semanticGapValue", "containerStyles.resolveBoxClassName"];
 export type AllowedTransformId = (typeof ALLOWED_TRANSFORM_IDS)[number];
 /**
  * Set for O(1) lookup of allowed node types.

package/dist/_dts/blocks/src/system/runtime/api/client.d.ts

@@ -3,7 +3,7 @@
  *
  * Factory function for creating a typed API client for block client-side API calls.
  */
-import type { BlockApiConfig, FormSubmitRequest, FormSubmitResponse, FormConfigResponse, BookingSubmitRequest, BookingPackageSubmitRequest, BookingSubmitResponse, EligibleAppointmentPackagesResponse, AppointmentBookingStatusRequest, AppointmentBookingStatusResponse, AvailableSlotsRequest, AvailableSlotsResponse, WeeklySlotAvailabilityRequest, WeeklySlotAvailabilityResponse, AvailableDatesRequest, AvailableDatesResponse, BookingServicesResponse, BookingServiceResponse, BookingResourcesResponse, PublicEventsRequest, PublicEvent, EventFiltersResponse, EventRegisterRequest, EventRegisterResponse, EventCheckoutRequest, EventCheckoutResponse, RegistrationOptionsRequest, RegistrationOptionsResponse, EventRegistrationStatusRequest, EventRegistrationStatusResponse, ResolveWaitlistClaimRequest, ResolveWaitlistClaimResponse, DiscountsAvailableRequest, DiscountsAvailableResponse, DiscountApplyRequest, DiscountApplyResponse, PublicProductsResponse, ShopCheckoutRequest, ShopCheckoutResponse, UnifiedCheckoutRequest, UnifiedCheckoutResponse, PublicGiftingOffersResponse, CreateGiftingCheckoutRequest, CreateGiftingCheckoutResponse, ClaimGiftCardRequest, ClaimGiftCardResponse, PortalMeResponse, CustomerProfile, CustomerOrder, PortalMeUpdateRequest, CustomerPass, CustomerMembership, CustomerEventRegistration, PortalEventTicket, CustomerAppointment, BookingQuestionsTaskDetail, CustomerEventSeriesRegistration, PortalCredit, PortalOrderCheckoutRequest, PortalOrderCheckoutResponse, PortalDigitalProductAccessResponse, PortalDigitalProductDownloadUrlResponse, PortalDigitalProductsResponse, PortalCancelWholeSeriesRegistrationRequest, PortalCancelWholeSeriesRegistrationResult, PortalCancelAppointmentRequest, PortalCancelAppointmentResult, PortalUpdateAppointmentBookingQuestionsRequest, PortalUpdateWholeSeriesBookingQuestionsRequest, PortalUpdateEventBookingQuestionsRequest, PortalCancelEventRegistrationRequest, PortalCancelEventRegistrationResult, PortalTransferEventRegistrationRequest, PortalTransferEventRegistrationResult, PortalRescheduleAppointmentRequest, PortalRescheduleAppointmentResponse, PortalCancelMembershipAtPeriodEndResult, MagicLinkRequest, EventGuest, UpdateEventGuestsRequest, NewsletterSubscribeRequest, NewsletterSubscribeResponse } from './types';
+import type { BlockApiConfig, FormSubmitRequest, FormSubmitResponse, FormConfigResponse, BookingSubmitRequest, BookingPackageSubmitRequest, BookingSubmitResponse, EligibleAppointmentPackagesResponse, AppointmentBookingStatusRequest, AppointmentBookingStatusResponse, AvailableSlotsRequest, AvailableSlotsResponse, WeeklySlotAvailabilityRequest, WeeklySlotAvailabilityResponse, AvailableDatesRequest, AvailableDatesResponse, BookingServicesResponse, BookingServiceResponse, BookingResourcesResponse, PublicEventsRequest, PublicEvent, EventFiltersResponse, EventRegisterRequest, EventRegisterResponse, EventCheckoutRequest, EventCheckoutResponse, RegistrationOptionsRequest, RegistrationOptionsResponse, EventRegistrationStatusRequest, EventRegistrationStatusResponse, EventCheckoutReturnRequest, EventCheckoutReturnResponse, ResolveWaitlistClaimRequest, ResolveWaitlistClaimResponse, DiscountsAvailableRequest, DiscountsAvailableResponse, DiscountApplyRequest, DiscountApplyResponse, PublicProductsResponse, ShopCheckoutRequest, ShopCheckoutResponse, UnifiedCheckoutRequest, UnifiedCheckoutResponse, PublicGiftingOffersResponse, CreateGiftingCheckoutRequest, CreateGiftingCheckoutResponse, ClaimGiftCardRequest, ClaimGiftCardResponse, PortalMeResponse, CustomerProfile, CustomerOrder, PortalMeUpdateRequest, CustomerPass, CustomerMembership, CustomerEventRegistration, PortalEventTicket, CustomerAppointment, BookingQuestionsTaskDetail, CustomerEventSeriesRegistration, PortalCredit, PortalOrderCheckoutRequest, PortalOrderCheckoutResponse, PortalDigitalProductAccessResponse, PortalDigitalProductDownloadUrlResponse, PortalDigitalProductsResponse, PortalCancelWholeSeriesRegistrationRequest, PortalCancelWholeSeriesRegistrationResult, PortalCancelAppointmentRequest, PortalCancelAppointmentResult, PortalUpdateAppointmentBookingQuestionsRequest, PortalUpdateWholeSeriesBookingQuestionsRequest, PortalUpdateEventBookingQuestionsRequest, PortalCancelEventRegistrationRequest, PortalCancelEventRegistrationResult, PortalTransferEventRegistrationRequest, PortalTransferEventRegistrationResult, PortalRescheduleAppointmentRequest, PortalRescheduleAppointmentResponse, PortalCancelMembershipAtPeriodEndResult, MagicLinkRequest, EventGuest, UpdateEventGuestsRequest, NewsletterSubscribeRequest, NewsletterSubscribeResponse } from './types';
 type WithoutSiteId<T> = T extends unknown ? Omit<T, 'siteId'> : never;
 type PublicProductCategorySelector = Readonly<{
     kind: 'category';
@@ -49,6 +49,7 @@ export interface BlockApiClient {
     createEventCheckout(data: WithoutSiteId<EventCheckoutRequest>): Promise<EventCheckoutResponse>;
     getRegistrationOptions(data: Omit<RegistrationOptionsRequest, 'siteId'>): Promise<RegistrationOptionsResponse>;
     getEventRegistrationStatus(params: WithoutSiteId<EventRegistrationStatusRequest>): Promise<EventRegistrationStatusResponse>;
+    resolveEventCheckoutReturn(data: EventCheckoutReturnRequest): Promise<EventCheckoutReturnResponse>;
     resolveWaitlistClaim(data: Omit<ResolveWaitlistClaimRequest, 'siteId'>): Promise<ResolveWaitlistClaimResponse>;
     getDiscountsAvailable(data: Omit<DiscountsAvailableRequest, 'siteId'>): Promise<DiscountsAvailableResponse>;
     applyDiscountCode(data: Omit<DiscountApplyRequest, 'siteId'>): Promise<DiscountApplyResponse>;

package/dist/_dts/blocks/src/system/runtime/api/endpoints.d.ts

@@ -101,6 +101,10 @@ export declare const EVENTS: {
         path: string;
         method: "GET";
     };
+    checkoutReturn: {
+        path: string;
+        method: "POST";
+    };
 };
 export declare const WHOLE_SERIES: {
     list: {
@@ -428,6 +432,10 @@ export declare const ENDPOINTS: {
             path: string;
             method: "GET";
         };
+        checkoutReturn: {
+            path: string;
+            method: "POST";
+        };
     };
     readonly wholeSeries: {
         list: {