@riverbankcms/sdk 0.147.0 → 0.149.0

package/dist/_dts/content-editor/src/ui/editorValueSnapshot.d.ts

@@ -0,0 +1,18 @@
+import { type EditorBlockValues, type EditorContentValues, type EditorMetadataValues, type EditorValueRecord, type ValueSync } from '../../../core/src/index';
+/**
+ * One editor value: its sync state (baseline, local intent and request) plus the
+ * published baseline. `version` counts changes for history, subscriptions and publish
+ * reconciliation; it is never a save acknowledgement.
+ */
+export type EditorValueSnapshot<TValue extends EditorValueRecord | null> = Readonly<{
+    version: number;
+    sync: ValueSync<TValue>;
+    publishedBaseline: TValue;
+}>;
+export type EditorBrandedValues = EditorMetadataValues | EditorContentValues | EditorBlockValues;
+export type NullableEditorValues<TValue extends EditorBrandedValues> = TValue | null;
+export declare function createValueSnapshot<TValue extends EditorBrandedValues>(): EditorValueSnapshot<NullableEditorValues<TValue>>;
+type ValueSnapshotUpdates<TValue extends EditorValueRecord | null> = Partial<Pick<EditorValueSnapshot<TValue>, 'sync' | 'publishedBaseline'>>;
+/** Applies updates, bumping `version` only when something changed. */
+export declare function updateValueSnapshot<TValue extends EditorValueRecord | null>(snapshot: EditorValueSnapshot<TValue>, updates: ValueSnapshotUpdates<TValue>): EditorValueSnapshot<TValue>;
+export {};

package/dist/_dts/content-editor/src/ui/serverBlockAdmission.d.ts

@@ -0,0 +1,26 @@
+import type { EditorBlockId, EditorBlockVersions } from '../../../core/src/index';
+import { type BlockFieldExtensions } from '../../../editor-blocks/src/block-editor/blockDraftBaselineSeed';
+import type { ServerBlockItem } from '../../../editor-blocks/src/block-editor/types';
+import type { RefreshPolicy } from '../sync/valueSync';
+import type { EditorHistorySnapshot } from './editorSnapshot';
+export type ServerBlockAdmission = Readonly<{
+    block: ServerBlockItem;
+    action: 'reconcile' | 'replace';
+}>;
+/** Seed preparation and the request-aware refresh reducer are the sole draft admission transition. */
+export declare function prepareServerBlockAdmissions(entries: readonly ServerBlockAdmission[], extensions?: BlockFieldExtensions | null): {
+    action: "replace" | "reconcile";
+    seed: Readonly<{
+        blockId: EditorBlockId;
+        baseline: import("../../../core/src/index").EditorBlockBaselineInput;
+        initMeta: import("../../../core/src/index").EditorDraftBlockInitMetaInput;
+        refreshMeta: import("../../../core/src/index").EditorDraftBlockBaselineUpdateMetaInput;
+    }>;
+    versions: Readonly<{
+        draftContentId: import("../../../core/src/index").ContentVersionId | null;
+        publishedPlacement: import("../../../core/src/index").PublishedBlockPlacementRead;
+    }>;
+}[];
+export declare function admitBlockDrafts(snapshot: EditorHistorySnapshot, entries: ReturnType<typeof prepareServerBlockAdmissions>, policy?: RefreshPolicy): EditorHistorySnapshot;
+/** History can restore admitted blocks; it cannot invent server identity. */
+export declare function assertAdmittedDrafts(previous: EditorHistorySnapshot, next: EditorHistorySnapshot, requireVersions: (id: EditorBlockId) => EditorBlockVersions): void;

package/dist/_dts/content-editor/src/ui/stores/autosaveStore.d.ts

@@ -1,36 +1,25 @@
 /**
- * Autosave slice for managing autosave status and handle registration.
- *
- * This slice is critical for the publish workflow:
- * 1. Autosave hooks register handles via registerAutosave()
- * 2. Before publish, saveNow() / flushAllPending() may be called to ensure all changes are saved
- * 3. useEntryActions waits for all saves to complete via status subscriptions
+ * The autosave handle registry. Each scheduler registers its handle; `flushValues`
+ * is the one waiter for "saved before X" (publish, Save draft, slot switches, generated
+ * icons) and asks the handles to send through `sendRequests`. Status isn't stored here:
+ * it's derived from the values (`selectAutosaveStatus`, issue 1553).
  */
-import type { AutosaveStatus, AutosaveHandle, AutosaveType } from './types';
+import type { FlushPolicy, FlushRequest, FlushResult, SendAcknowledgement } from '../../sync/sendPlanning';
+import type { FlushOptions } from '../../sync/flushValues';
+import type { AutosaveHandle, AutosaveType } from './types';
 export type AutosaveState = {
-    metadata: AutosaveStatus;
-    content: AutosaveStatus;
-    blocks: AutosaveStatus;
-    linkedEntries: AutosaveStatus;
-    setMetadataStatus: (status: Partial<AutosaveStatus>) => void;
-    setContentStatus: (status: Partial<AutosaveStatus>) => void;
-    setBlocksStatus: (status: Partial<AutosaveStatus>) => void;
-    setLinkedEntriesStatus: (status: Partial<AutosaveStatus>) => void;
     registerAutosave: (type: AutosaveType, handle: AutosaveHandle) => void;
     unregisterAutosave: (type: AutosaveType) => void;
-    /**
-     * Immediately saves the given autosave types by triggering and flushing their handles.
-     *
-     * Unlike flushAllPending(), this does not rely on a debounced callback being pending, so it
-     * works for manual-save mode where background triggers are disabled.
-     */
-    saveNow: (types: AutosaveType[]) => Promise<void>;
-    flushAllPending: () => void;
+    registeredSchedulers: () => readonly AutosaveType[];
+    /** Sends each request's values in its scheduler's next batch; resolves once the batches finish. */
+    sendRequests: (requests: readonly FlushRequest[]) => Promise<readonly SendAcknowledgement[]>;
+    /** Resolves once the values in scope are saved, or can't be (`planFlush`). */
+    flushValues: (policy: FlushPolicy, options?: FlushOptions) => Promise<FlushResult>;
+    cancelPending: (scheduler: AutosaveType) => void;
     cancelAllPending: () => void;
 };
 /**
- * Creates the autosave slice for managing autosave status and handles.
- *
- * @param triggerUpdate - Callback to trigger React re-renders
+ * Creates the autosave registry. `flush` is the store-bound `flushValues`; the registry
+ * holds no status of its own.
  */
-export declare function createAutosaveSlice(triggerUpdate: () => void): AutosaveState;
+export declare function createAutosaveSlice(flush: (policy: FlushPolicy, options?: FlushOptions) => Promise<FlushResult>): AutosaveState;

package/dist/_dts/content-editor/src/ui/stores/blockVersionsStore.d.ts

@@ -0,0 +1,24 @@
+import { type EditorBlockId, type EditorBlockVersions, type EditorBlockVersionsEntry, type SavedBlockContentVersion } from '../../../../core/src/index';
+/**
+ * Server versions per block. Server-owned, so this lives outside undo history:
+ * undoing an edit never brings back an id the server has already replaced.
+ */
+export type BlockVersionsState = Readonly<{
+    revision: number;
+    /** Null for blocks not admitted to this editor. */
+    get: (blockId: EditorBlockId) => EditorBlockVersions | null;
+    require: (blockId: EditorBlockId) => EditorBlockVersions;
+    set: (entries: readonly EditorBlockVersionsEntry[]) => void;
+    applySaved: (blockId: EditorBlockId, saved: SavedBlockContentVersion) => void;
+}>;
+type BlockVersionsSnapshot = Readonly<{
+    byId: ReadonlyMap<EditorBlockId, EditorBlockVersions>;
+    revision: number;
+}>;
+export declare function withBlockVersions(snapshot: BlockVersionsSnapshot, entries: readonly EditorBlockVersionsEntry[]): BlockVersionsSnapshot;
+/** Internal record operation lets the editor commit versions and drafts before notifying. */
+export declare function createBlockVersionsSlice(triggerUpdate: () => void): Readonly<{
+    state: BlockVersionsState;
+    record: (entries: readonly EditorBlockVersionsEntry[]) => boolean;
+}>;
+export {};

package/dist/_dts/content-editor/src/ui/stores/linkedEntryLeaseStore.d.ts

@@ -0,0 +1,54 @@
+import type { ApiClient } from '../../../../api/src/request';
+import type { DraftTarget } from '../../../../realtime/src/index';
+import { type EditorEditability } from '../../controller/editorEditability';
+export type LinkedEntryLeaseBinding = Readonly<{
+    contentTypeKey: string;
+    apiClient: ApiClient;
+    takeOver: () => void;
+    retry: () => void;
+}>;
+export type LinkedEntryLeaseSession = LinkedEntryLeaseBinding & (Readonly<{
+    kind: 'linked';
+    editability: EditorEditability;
+    discarded: boolean;
+}> | Readonly<{
+    kind: 'parent';
+}>);
+type WriteAuthorityState = Pick<LinkedEntryLeaseState, 'linkedEntryLeases'> & Readonly<{
+    editability: EditorEditability;
+}>;
+type LeaseOwnerState = Pick<LinkedEntryLeaseState, 'linkedEntryLeases'> & Readonly<{
+    editability: EditorEditability;
+    leaseDiscardedChanges: boolean;
+}>;
+export declare function readLinkedEntryLease(state: LeaseOwnerState, entryId: string): (Readonly<{
+    contentTypeKey: string;
+    apiClient: ApiClient;
+    takeOver: () => void;
+    retry: () => void;
+}> & Readonly<{
+    kind: "linked";
+    editability: EditorEditability;
+    discarded: boolean;
+}>) | {
+    editability: EditorEditability;
+    discarded: boolean;
+    contentTypeKey: string;
+    apiClient: ApiClient;
+    takeOver: () => void;
+    retry: () => void;
+    kind: "parent";
+} | undefined;
+export type LinkedEntryLeaseState = {
+    linkedEntryLeases: Readonly<Record<string, LinkedEntryLeaseSession | undefined>>;
+    registerLinkedEntryLease: (entryId: string, binding: LinkedEntryLeaseBinding, kind: LinkedEntryLeaseSession['kind']) => void;
+    setLinkedEntryLease: (entryId: string, session: LinkedEntryLeaseSession | undefined) => void;
+};
+export declare function createLinkedEntryLeaseSlice(set: (update: (state: LinkedEntryLeaseState) => Partial<LinkedEntryLeaseState>) => void): LinkedEntryLeaseState;
+export declare function canWriteLinkedEntry(state: WriteAuthorityState, entryId: string): boolean;
+/**
+ * Per-item write authority, shared by autosave and the live-drafts projection: the
+ * document's own values follow the document lease; a linked entry follows its own.
+ */
+export declare function canWriteDraftTarget(state: WriteAuthorityState, target: DraftTarget): boolean;
+export {};

package/dist/_dts/content-editor/src/ui/stores/linkedSaveHandoversStore.d.ts

@@ -0,0 +1,11 @@
+import { type LinkedSaveHandovers } from '../../liveDrafts/linkedSaveHandovers';
+/**
+ * This tab's accepted linked-entry saves, handing over to the rendered data (issue 1553, D).
+ * Outside history, snapshots and autosave, beside `remoteDrafts`: `settle` records them,
+ * and the renderer's retention replaces the map as they drop.
+ */
+export type LinkedSaveHandoversState = {
+    linkedSaveHandovers: LinkedSaveHandovers;
+    setLinkedSaveHandovers: (handovers: LinkedSaveHandovers) => void;
+};
+export declare function createLinkedSaveHandoversSlice(set: (update: (state: LinkedSaveHandoversState) => Partial<LinkedSaveHandoversState>) => void): LinkedSaveHandoversState;

package/dist/_dts/content-editor/src/ui/stores/remoteDraftsStore.d.ts

@@ -0,0 +1,10 @@
+import { type RemoteDraftOverlay } from '../../liveDrafts/remoteDraftOverlay';
+/**
+ * Read-only overlay of another tab's live drafts (issue 1545). Deliberately outside
+ * history, snapshots, autosave and linked-entry save inputs: only the renderer reads it.
+ */
+export type RemoteDraftsState = {
+    remoteDrafts: RemoteDraftOverlay;
+    setRemoteDrafts: (overlay: RemoteDraftOverlay) => void;
+};
+export declare function createRemoteDraftsSlice(set: (update: (state: RemoteDraftsState) => Partial<RemoteDraftsState>) => void): RemoteDraftsState;

package/dist/_dts/content-editor/src/ui/stores/types.d.ts

@@ -1,17 +1,77 @@
-import type { EditorBlockId } from '../../../../core/src/index';
+import type { EditorBlockId, SendId } from '../../../../core/src/index';
+import type { FlushCheckpoint, SendAcknowledgement } from '../../sync/sendPlanning';
+import type { EditorValueKey } from '../editorSnapshot';
 export type AutosaveStatusValue = 'idle' | 'saving' | 'success' | 'error';
 export type AutosaveStatus = {
     status: AutosaveStatusValue;
     lastSavedAt: string | null;
     hasFailedSaves: boolean;
 };
+/**
+ * One autosave scheduler's handle. `sendNow` sends the given values in the scheduler's
+ * next batch, retrying failures explicitly, alongside anything the background would send.
+ */
 export type AutosaveHandle = {
     trigger: () => void;
-    cancel?: () => void;
-    flush: () => void | Promise<void>;
+    cancel: () => void;
+    flush: () => Promise<void>;
     isPending: () => boolean;
+    sendNow: (keys: readonly EditorValueKey[], checkpoints?: readonly FlushCheckpoint[], signal?: AbortSignal) => Promise<readonly SendAcknowledgement[]>;
 };
 export type AutosaveType = 'metadata' | 'content' | 'blocks' | 'linkedEntries';
+/**
+ * Operations that write the document's route or draft on the server; while one's request
+ * is out, the document's values are held (issue 1553, B-ownership).
+ */
+export type HeldOperation = 'publish' | 'schedule' | 'cancel-schedule' | 'discard-draft' | 'delete';
+/** Operations on the whole document; their status sits beside the values' (issue 1553). */
+export type LifecycleOperation = 'save-draft' | 'restore-replay' | HeldOperation;
+/**
+ * Why an operation didn't happen. `server` is a refused request; the others are refusals
+ * before any request: values whose saves failed, values that can't be sent (not writable
+ * or not saveable), and blocks that fail publish validation.
+ */
+export type LifecycleFailure = Readonly<{
+    kind: 'server';
+    message: string;
+}> | Readonly<{
+    kind: 'values-failed';
+    ids: readonly SendId[];
+}> | Readonly<{
+    kind: 'values-blocked';
+    keys: readonly EditorValueKey[];
+}> | Readonly<{
+    kind: 'invalid-blocks';
+}>;
+/**
+ * A failed status records the failure and how many saves had been accepted when it
+ * failed, so whether it still holds is derived (`activeFailure`) rather than cleared.
+ * `holding` is a held operation whose request is out (or about to be): the document's
+ * values aren't sent until it ends, and edits typed meanwhile wait (`schedulerValues`).
+ */
+export type LifecycleStatus = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'running';
+    operation: LifecycleOperation;
+}> | Readonly<{
+    kind: 'holding';
+    operation: HeldOperation;
+}> | Readonly<{
+    kind: 'failed';
+    operation: LifecycleOperation;
+    failure: LifecycleFailure;
+    acceptedSaves: number;
+}>;
+/** What a lifecycle action tells its caller. Expected refusals are results, not throws. */
+export type LifecycleOutcome = Readonly<{
+    kind: 'done';
+}> | Readonly<{
+    kind: 'no-changes';
+}> | Readonly<{
+    kind: 'failed';
+    failure: LifecycleFailure;
+}>;
 export type FocusSettingsTab = 'display' | 'behavior' | 'style';
 export type FocusTarget = Readonly<{
     kind: 'block';

package/dist/_dts/content-editor/src/useFooterComposerState.d.ts

@@ -1,12 +1,12 @@
 import { type FooterCompositionSnapshot, type PublicProfileSnapshot } from '../../api/src/footer-settings';
-import type { ApiClient } from '../../api/src/request';
+import type { FooterComposerPanelProps } from './footerComposerPanelTypes';
 import { type FooterCompositionV1, type PublicProfile } from '../../core/src/index';
 import type { FooterEditorTarget } from './footerComposer';
 import { type FooterNavigationLayoutAccess } from './useFooterNavigationLayout';
 export type SaveState = 'idle' | 'saving' | 'saved' | 'conflict' | 'failed';
 export type CompositionSaveOutcome = 'saved' | 'conflict' | 'failed';
 type FooterComposerStateOptions = Readonly<{
-    apiClient: ApiClient;
+    apiClient: FooterComposerPanelProps['apiClient'];
     canEdit: boolean;
     initialTarget?: FooterEditorTarget;
     initialTargetRequestId?: number;

package/dist/_dts/content-editor/src/useFooterNavigationLayout.d.ts

@@ -11,7 +11,7 @@ export type FooterNavigationLayoutAccess = Readonly<{
     selectionVersion: number;
 }>;
 export declare function useFooterNavigationLayout({ apiClient, siteId, access, onSaved, onSaveStateChange, onMessageChange, }: Readonly<{
-    apiClient: ApiClient;
+    apiClient: ApiClient<'applySiteStyleSelection'>;
     siteId: string;
     access: FooterNavigationLayoutAccess;
     onSaved?: () => void;

package/dist/_dts/content-model/src/content-types/builtin-schemas.d.ts

@@ -58,18 +58,18 @@ export declare const EVENT_CONTENT_TYPE_SCHEMA: {
         readonly id: "summary";
         readonly type: "textarea";
         readonly label: "Short introduction";
-        readonly description: "Write one or two sentences that help people quickly understand what this is. It appears wherever the event is listed and near the top of its page.";
+        readonly description: "Shown in your listings and search results, and at the top of its page.";
         readonly rows: 3;
     }, {
         readonly id: "image";
         readonly type: "media";
         readonly label: "Event image";
-        readonly description: "Choose the main image people will see wherever the event is listed and on its page.";
+        readonly description: "At the top of its page and beside it in your listings.";
     }, {
         readonly id: "body";
         readonly type: "richText";
-        readonly label: "About this event";
-        readonly description: "Add the main information people need before booking—what to expect, who it’s for, what’s included, and anything they should bring or know.";
+        readonly label: "Full description";
+        readonly description: "The main text on its page, under the introduction.";
     }];
     readonly routing: {
         readonly enabled: true;

package/dist/_dts/content-model/src/content-types/builtins.d.ts

@@ -161,18 +161,18 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
             readonly id: "summary";
             readonly type: "textarea";
             readonly label: "Short introduction";
-            readonly description: "Write one or two sentences that help people quickly understand what this is. It appears wherever the event is listed and near the top of its page.";
+            readonly description: "Shown in your listings and search results, and at the top of its page.";
             readonly rows: 3;
         }, {
             readonly id: "image";
             readonly type: "media";
             readonly label: "Event image";
-            readonly description: "Choose the main image people will see wherever the event is listed and on its page.";
+            readonly description: "At the top of its page and beside it in your listings.";
         }, {
             readonly id: "body";
             readonly type: "richText";
-            readonly label: "About this event";
-            readonly description: "Add the main information people need before booking—what to expect, who it’s for, what’s included, and anything they should bring or know.";
+            readonly label: "Full description";
+            readonly description: "The main text on its page, under the introduction.";
         }];
         readonly routing: {
             readonly enabled: true;

package/dist/_dts/content-model/src/definitions/shared.d.ts

@@ -69,8 +69,6 @@ type EnsureRecord<T extends Record<string, unknown>> = T;
 export type RoutableMetadataValues = EnsureRecord<{
     draftTitle: string;
     draftSlug: string;
-    draftStatus: string;
-    scheduledPublishAt: string | null;
     draftMetaTitle: string | null;
     draftMetaDescription: string | null;
     ogImageId: string | null;
@@ -87,6 +85,17 @@ export declare function createMetadataStateFromSnapshot(snapshot: ContentEntrySn
     values: RoutableMetadataValues | Record<string, never>;
     baseline: RoutableMetadataValues | Record<string, never>;
 };
+/**
+ * The route's lifecycle fields as the editor reads them: from the entry snapshot, never
+ * from metadata values (issue 1553, FO2). Lifecycle operations (publish, schedule,
+ * cancel, discard) own them; forms get them read-only, e.g. slug auto-generation's
+ * `statusFieldId`. Non-routable content has none.
+ */
+export type RouteLifecycleContext = Readonly<{
+    draftStatus: string;
+    scheduledPublishAt: string | null;
+}>;
+export declare function routeLifecycleContext(snapshot: ContentEntrySnapshot): RouteLifecycleContext | null;
 /**
  * Extract published metadata values from a snapshot.
  * Used to set the publishedBaseline for unpublished changes detection.

package/dist/_dts/content-model/src/entry-slots/index.d.ts

@@ -1,2 +1,3 @@
 export * from './types';
+export * from './serializeAllowedBlocks';
 export * from './sdkBlocks';

package/dist/_dts/content-model/src/entry-slots/serializeAllowedBlocks.d.ts

@@ -0,0 +1,2 @@
+import type { EntrySlotAllowedBlocks, EntrySlotDefinition } from './types';
+export declare function serializeEntrySlotAllowedBlocks(definition: EntrySlotDefinition): EntrySlotAllowedBlocks;

package/dist/_dts/content-model/src/metadataConfig.d.ts

@@ -33,7 +33,7 @@ export type RouteMetadataPresentation = Readonly<{
     manifest: RouteMetadataManifest;
     typeKey: string | null;
 }>;
-export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftStatus" | "scheduledPublishAt" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
+export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
 type RouteMetadataTextField = {
     id: "draftTitle" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
     type: "text";
@@ -54,39 +54,17 @@ type RouteMetadataSlugField = {
     description: string;
     required: true;
     sourceFieldId?: "draftTitle";
+    /**
+     * Auto-generation runs only while this reads "draft". It isn't a metadata value: the
+     * form backend supplies it read-only from the entry snapshot (`routeLifecycleContext`).
+     */
     statusFieldId: "draftStatus";
     maxLength: number;
     ui: {
         showSlugPreview: true;
     };
 };
-type RouteMetadataSelectField = {
-    id: "draftStatus";
-    type: "select";
-    label: string;
-    description: string;
-    required: true;
-    defaultValue: string;
-    options: Array<{
-        value: string;
-        label: string;
-    }>;
-    multiple: false;
-};
-type RouteMetadataDatetimeField = {
-    id: "scheduledPublishAt";
-    type: "datetime";
-    label: string;
-    description: string;
-    required: false;
-    ui: {
-        visibleWhen: {
-            field: "draftStatus";
-            equals: "scheduled";
-        };
-    };
-};
-export type RouteMetadataField = RouteMetadataTextField | RouteMetadataSlugField | RouteMetadataSelectField | RouteMetadataDatetimeField;
+export type RouteMetadataField = RouteMetadataTextField | RouteMetadataSlugField;
 export type RouteMetadataManifest = {
     name: string;
     version: string;
@@ -97,22 +75,16 @@ export type RouteMetadataManifest = {
     slots: [];
 };
 export declare const ROUTE_METADATA_MANIFEST: RouteMetadataManifest;
-export declare const METADATA_WORKFLOW_FIELDS: {
-    readonly title: "draftTitle";
-    readonly slug: "draftSlug";
-    readonly status: "draftStatus";
-    readonly publishAt: "scheduledPublishAt";
-};
 export declare function pageRouteSlugFromEditorValue(value: string | null | undefined): PageRouteSlug;
 export declare function pageRouteSlugToEditorValue(slug: PageRouteSlug): string;
 export declare function pageRouteSlugToStoredValue(slug: PageRouteSlug): string | null;
 export declare function isHomepagePageRouteSlug(slug: PageRouteSlug): boolean;
 export declare function resolvePageRouteSlug(entry: ContentEntrySnapshot, currentSlug?: string | null): PageRouteSlug | null;
 export declare const ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE: {
-    readonly event: readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
-    readonly product: readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
-    readonly "product-category": readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
-    readonly "team-member": readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
+    readonly event: readonly ["draftTitle", "draftSlug"];
+    readonly product: readonly ["draftTitle", "draftSlug"];
+    readonly "product-category": readonly ["draftTitle", "draftSlug"];
+    readonly "team-member": readonly ["draftTitle", "draftSlug"];
 };
 export declare function getManagedRouteMetadataFieldIdsForType(typeKey: string | null | undefined): ReadonlyArray<RouteMetadataFieldId>;
 export declare function isRouteMetadataFieldEditableForType(typeKey: string | null | undefined, fieldId: string): boolean;

package/dist/_dts/content-model/src/templates/defaults.d.ts

@@ -154,7 +154,6 @@ export declare const DEFAULT_TEMPLATE_DEFINITIONS: {
                 readonly maxTickets: "5";
                 readonly showVenue: true;
                 readonly showCapacity: true;
-                readonly successMessage: "Thank you for registering! Check your email for confirmation details.";
                 readonly buttonText: "Complete Registration";
                 readonly buttonVariant: "primary";
             };

package/dist/_dts/content-model/src/types.d.ts

@@ -74,7 +74,6 @@ export type ContentEntryDefinition<TEntry extends ContentEntrySnapshot, TValues
     routing: RoutingHelpers;
     hasRoute: boolean;
     services: {
-        saveMetadata: (payload: TMetadataPayload) => Promise<TMetadataResponse>;
         publish: (payload: TPublishPayload | undefined) => Promise<TEntry>;
         discardDraft: () => Promise<TEntry>;
         deleteEntry: () => Promise<void>;

package/dist/_dts/core/src/block-content-identity.d.ts

@@ -1,5 +1,53 @@
-/** A block version ID is meaningful only with its draft or published stage. */
+import { type ContentVersionId } from './branded';
+/** A block version ID is meaningful only with its draft or published stage (wire shape). */
 export type BlockContentIdentity = Readonly<{
     draftContentId: string | null;
     publishedContentId: string | null;
 }>;
+/** A published version paired with the content it authorises. */
+export type PublishedBlockPlacement = Readonly<{
+    kind: 'published';
+    id: ContentVersionId;
+    content: Record<string, unknown>;
+}>;
+/**
+ * A published pointer the server sent without its content, or with an id that
+ * isn't a content version id. It can't be cited as published.
+ */
+export type IncompleteBlockPlacement = Readonly<{
+    kind: 'incomplete';
+    id: string | null;
+    content: Record<string, unknown> | null;
+}>;
+/** What a read of a block's published version finds; `null` when it was never published. */
+export type PublishedBlockPlacementRead = PublishedBlockPlacement | IncompleteBlockPlacement | null;
+/** The one pairing of a published id with its content. */
+export declare function readPublishedBlockPlacement(id: string | null | undefined, content: Record<string, unknown> | null | undefined): PublishedBlockPlacementRead;
+/**
+ * The server's versions of one editor block. This is server-owned state: the
+ * editor keeps it outside undo history, so undo never restores a replaced id.
+ */
+export type EditorBlockVersions = Readonly<{
+    draftContentId: ContentVersionId | null;
+    publishedPlacement: PublishedBlockPlacementRead;
+}>;
+export declare const NO_BLOCK_VERSIONS: EditorBlockVersions;
+/** The one conversion from wire identity to editor identity. */
+export declare function readEditorBlockVersions(wire: Partial<BlockContentIdentity> & Readonly<{
+    publishedContent?: Record<string, unknown> | null;
+}>): EditorBlockVersions;
+/** Editor identity from a render block, whose published placement is already paired. */
+export declare function readEditorBlockVersionsFromPlacement(draftContentId: string | null | undefined, publishedPlacement: PublishedBlockPlacementRead): EditorBlockVersions;
+/** The published version a block can cite, if it has a complete one. */
+export declare function publishedVersionOf(versions: EditorBlockVersions | undefined): PublishedBlockPlacement | null;
+/** The content version a block renders: its draft if it has one, else its published version. */
+export declare function selectedContentVersionId(versions: EditorBlockVersions): ContentVersionId | null;
+/** Published content the editor treats as its dirty-state baseline. */
+export declare function publishedContentOf(versions: EditorBlockVersions | undefined): Record<string, unknown> | null;
+export type SavedBlockContentVersion = Readonly<{
+    contentId: string;
+    stage: 'draft' | 'published';
+    data: unknown;
+}>;
+/** A block's versions after the server acknowledges one content save. */
+export declare function applySavedBlockContentVersion(versions: EditorBlockVersions, saved: SavedBlockContentVersion): EditorBlockVersions;

package/dist/_dts/core/src/booking-flexible-balance.d.ts

@@ -11,7 +11,7 @@ export type BookingFlexibleBalanceConfig = Readonly<{
     dueDateRule: BookingFlexibleBalanceDueDateRule;
     depositRefundability: BookingDepositRefundPolicy;
 }>;
-export type BookingFlexibleBalanceContractStatus = 'active' | 'payment_pending' | 'overdue' | 'completed' | 'waived' | 'cancelled_due_to_non_payment' | 'refunded';
+export type BookingFlexibleBalanceContractStatus = 'active' | 'payment_pending' | 'overdue' | 'completed' | 'waived' | 'cancelled_due_to_non_payment' | 'refunded' | 'closed_order_failed';
 export type BookingFlexibleBalanceReminderKind = 'due_7_days' | 'due_1_day' | 'overdue_1_day';
 export declare const DEFAULT_FLEXIBLE_BALANCE_STRIPE_MINIMUM_CHARGE_CENTS = 50;
 export type BookingFlexibleBalanceReminderState = Readonly<{
@@ -30,7 +30,7 @@ export type FlexibleBalancePaymentEligibility = Readonly<{
     reason: 'overdue' | 'dust_balance';
 }> | Readonly<{
     kind: 'unavailable';
-    reason: 'already_settled' | 'payment_pending' | 'cancelled_due_to_non_payment' | 'refunded' | 'waived';
+    reason: 'already_settled' | 'payment_pending' | 'cancelled_due_to_non_payment' | 'refunded' | 'waived' | 'order_failed';
 }>;
 export declare function resolveFlexibleBalanceInitialPaymentCents(input: Readonly<{
     totalAmountCents: number;

package/dist/_dts/core/src/booking-instalment-deposit.d.ts

@@ -0,0 +1,20 @@
+import { type Result } from './result';
+import { type BookingInstalmentPlanConfig } from './booking-instalments';
+import type { BookingPaymentCollectionOption } from './booking-payment-options';
+/** A plan that starts with a deposit whose deposit is below the card minimum. */
+export type InstalmentDepositBelowMinimum = Readonly<{
+    kind: 'instalment_deposit_below_minimum';
+    minimumCents: number;
+}>;
+/**
+ * A plan that starts with a deposit takes it by card when the customer books
+ * and saves the card for the later payments, so the deposit must be at least
+ * the card minimum for the site's currency. Plans without a deposit step
+ * (equal instalments) charge their first instalment instead and are not
+ * checked here.
+ */
+export declare function checkInstalmentPlanDeposit(plan: BookingInstalmentPlanConfig, minimumCents: number): Result<void, InstalmentDepositBelowMinimum>;
+/** The deposit check for whichever instalment option a set of payment options offers. */
+export declare function checkPaymentOptionsInstalmentDeposit(allowedOptions: readonly BookingPaymentCollectionOption[], minimumCents: number): Result<void, InstalmentDepositBelowMinimum>;
+/** The one message for a deposit below the minimum, shown in the editor and returned by the server. */
+export declare function describeInstalmentDepositBelowMinimum(failure: InstalmentDepositBelowMinimum, currency: string): string;