@riverbankcms/sdk 0.147.0 → 0.148.0

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

@@ -1,16 +1,33 @@
-import type { FooterModuleId } from '../../../core/src/index';
+import { type BlockFieldExtensions } from '../../../editor-blocks/src/block-editor/blockDraftBaselineSeed';
+import type { EditorBlockCollectionOwner, EditorBlockCollectionReadBaseline } from '../../../core/src/index';
+import { type ServerBlockAdmission } from './serverBlockAdmission';
+import { type BlockVersionsState } from './stores/blockVersionsStore';
+import { type EditorBlockVersions, type EditorInsertBlockCommand, type SavedBlockContentVersion } from '../../../core/src/index';
+import type { ServerBlockItem } from '../../../editor-blocks/src/block-editor/types';
+import { type DocumentLifecycleResult } from './documentLifecycle';
+import type { EditorValueRecord, FooterModuleId } from '../../../core/src/index';
+import type { EditorLeaseUiState } from './editorLeaseUiState';
+import type { DraftsSlice } from '../../../editor-blocks/src/block-editor/types';
+import { type EditorEditability } from '../controller/editorEditability';
+export { unmanagedSurfaceEditability } from '../controller/editorEditability';
+import { type LinkedEntryLeaseState } from './stores/linkedEntryLeaseStore';
+import { type DocumentValueRefreshInput, type OwnWrite, type PublishSuccessRefresh, type ValueRefresh } from './editorRefresh';
+import { type RemoteDraftsState } from './stores/remoteDraftsStore';
+import { type LinkedSaveHandoversState } from './stores/linkedSaveHandoversStore';
 import { type EditorUnpublishedState } from '../controller/deriveEditorUnpublishedState';
 import { type AutosaveState } from './stores/autosaveStore';
 import { type GeneratedIconAssetsState } from './stores/generatedIconAssetsStore';
 import { type ArrayKeysState } from './stores/arrayKeysStore';
 import { type ViewportState } from './stores/viewportStore';
 import { type AiOverlaysState } from './stores/aiOverlaysSlice';
-import { type EditorValueSnapshot, type EditorBlockItem, type EditorBlockId, type NormalizedEditorBlockItem, type DraftBlockBaselineInput, type DraftBlockBaselineUpdateMetaInput, type DraftBlockInitMetaInput, type EditorCommand, type EditorContentValues, type EditorDraftSnapshot, type EditorDraftUnpublishedBlockChange, type EditorEffect, type EditorHistorySnapshot, type EditorLinkedEntrySnapshot, type EditorMetadataValues, type BlockPublishedBaselineInput } from './editorHistory';
+import { type EditorValueSnapshot, type EditorBlockItem, type EditorBlockId, type NormalizedEditorBlockItem, type EditorCommand, type EditorContentValues, type EditorDraftUnpublishedBlockChange, type EditorEffect, type EditorHistorySnapshot, type EditorLinkedEntrySnapshot, type EditorMetadataValues, type EditorValueKey, type StartedSend } from './editorHistory';
+import { type RefreshPolicy, type SendMode, type ValueSyncOutcome } from '../sync/valueSync';
+import type { BaselineRevision, SaveFailure, SendId, ValueSync } from '../../../core/src/index';
 import { type HistoryState } from './editorHistory';
-import type { FocusRequest, FocusTarget } from './stores/types';
-import { type LinkedContentEntryId } from '../linkedEntries/domain';
+import type { FocusRequest, FocusTarget, HeldOperation, LifecycleFailure, LifecycleOperation, LifecycleStatus } from './stores/types';
+import { type LinkedContentEntryId, type LinkedEntryOpenTarget } from '../linkedEntries/domain';
 import { type BlockDraftSaveability, type BlockDraftValidationIssue, type ResolveBlockManifest } from './blockValidationView';
-export type { AutosaveStatusValue, AutosaveStatus, AutosaveHandle, AutosaveType, AutosaveType as AutosaveSchedulerKey, FocusRequest, ViewportMode, ViewportWidth, ZoomLevel, } from './stores/types';
+export type { AutosaveStatusValue, AutosaveStatus, AutosaveHandle, AutosaveType, FocusRequest, HeldOperation, LifecycleFailure, LifecycleOperation, LifecycleOutcome, LifecycleStatus, ViewportMode, ViewportWidth, ZoomLevel, } from './stores/types';
 export type { AutosaveState } from './stores/autosaveStore';
 export type { ArrayKeysState } from './stores/arrayKeysStore';
 export type { ViewportState } from './stores/viewportStore';
@@ -41,15 +58,24 @@ export type ActivePreviewField = (Readonly<{
     entryId: LinkedContentEntryId;
     fieldPath: string;
 }>) | null;
-/**
- * Version of the local draft snapshot that a completed autosave request persisted.
- * The reducer uses this to accept the saved baseline without treating older
- * in-flight saves as acknowledgements of newer local edits.
- */
-export type AutosaveAcknowledgement = Readonly<{
-    acknowledgedVersion: number;
-    optimisticHash?: string | null;
+/** How a save request settled. `at` is the ISO time the shell observed the response. */
+export type SendResult = Readonly<{
+    kind: 'succeeded';
+    values: Record<string, unknown> | null;
+    revision: BaselineRevision;
+    at: string;
+    published?: Readonly<{
+        kind: 'known';
+        values: Record<string, unknown> | null;
+    } | {
+        kind: 'unknown';
+    }>;
+    blockVersion?: SavedBlockContentVersion;
+}> | Readonly<{
+    kind: 'failed';
+    failure: SaveFailure;
 }>;
+export type { EditorValueKey, StartedSend } from './editorHistory';
 /**
  * Form-facing metadata facade. Consumers pass plain records for ergonomics;
  * the reducer core normalizes and brands values at this boundary.
@@ -57,16 +83,16 @@ export type AutosaveAcknowledgement = Readonly<{
 export type MetadataState = {
     getSnapshot: () => MetadataSnapshot;
     getCurrentValues: () => Record<string, unknown> | null;
-    hydrate: (baseline: Record<string, unknown> | null, current?: Record<string, unknown> | null, published?: Record<string, unknown> | null) => void;
+    /**
+     * Applies a server read of this value as a refresh event (issue 1553). Ordinary
+     * refreshes are keep-local; returns whether local edits were discarded.
+     */
+    refresh: (input: DocumentValueRefreshInput, policy?: RefreshPolicy) => boolean;
     setPublishedBaseline: (published: Record<string, unknown> | null) => void;
     hasUnpublishedChanges: () => boolean;
-    setBaseline: (baseline: Record<string, unknown> | null) => void;
     setCurrentValues: (values: Record<string, unknown> | null) => void;
     setAtPath: (path: string, value: unknown) => void;
     getAtPath: <R = unknown>(path: string) => R | undefined;
-    autosaveSucceeded: (savedValues: Record<string, unknown> | null, acknowledgement?: AutosaveAcknowledgement) => void;
-    autosaveFailed: (message?: string) => void;
-    clearError: () => void;
 };
 export type ContentState = Omit<MetadataState, 'getSnapshot'> & {
     getSnapshot: () => ContentSnapshot;
@@ -91,18 +117,7 @@ export type PreviewInspection = Readonly<{
 }>;
 export type LinkedEntryState = {
     getSelectedEntryId: () => LinkedContentEntryId | null;
-    open: (target: {
-        entryId: string;
-        contentTypeKey: string;
-        contentTypeLabel: string;
-        title: string;
-        optimisticHash?: string | null;
-        content: Record<string, unknown>;
-        contentType: {
-            titleField?: string | null;
-            fields: readonly Record<string, unknown>[];
-        };
-    }) => void;
+    open: (target: LinkedEntryOpenTarget) => void;
     close: () => void;
     discard: (entryId?: string) => void;
     getSelectedSnapshot: () => EditorLinkedEntrySnapshot | null;
@@ -112,11 +127,6 @@ export type LinkedEntryState = {
     setCurrentValues: (values: Record<string, unknown> | null, entryId?: string) => void;
     setAtPath: (path: string, value: unknown, entryId?: string) => void;
     getAtPath: <R = unknown>(path: string, entryId?: string) => R | undefined;
-    saveSucceeded: (entryId: string, content: Record<string, unknown> | null, acknowledgement?: AutosaveAcknowledgement & {
-        optimisticHash?: string | null;
-    }) => void;
-    saveFailed: (entryId: string, message?: string) => void;
-    clearError: (entryId?: string) => void;
 };
 export type EditorPreviewInspectorStore = {
     getState: () => {
@@ -127,6 +137,12 @@ export type EditorPreviewInspectorStore = {
             structure?: AiOverlaysState['structure'];
         }>;
         linkedEntries: Pick<LinkedEntryState, 'inspect'>;
+        blockVersions: Pick<BlockVersionsState, 'get' | 'revision'>;
+        remoteDrafts?: RemoteDraftsState['remoteDrafts'];
+        linkedSaveHandovers?: LinkedSaveHandoversState['linkedSaveHandovers'];
+        content?: Pick<ContentState, 'getSnapshot'>;
+        /** Decides the render source: a viewer renders live drafts, any other tab its own edits. */
+        editability: EditorEditability;
     };
 };
 export type EditorHistoryState = HistoryState<EditorHistorySnapshot>;
@@ -155,54 +171,40 @@ export type BlockValidationState = {
     } | null;
     getBlockSaveability: (blockId: EditorBlockId) => BlockDraftSaveability;
 };
-export type DraftsState = {
-    getBlockSnapshot: (blockId: EditorBlockId) => EditorDraftSnapshot | null;
-    getCurrentValues: (blockId: EditorBlockId) => Record<string, unknown> | null;
-    inspect: () => EditorDraftSnapshot[];
-    /**
-     * Form-facing drafts facade. Baseline inputs stay unbranded so editor consumers
-     * can pass raw form values; the reducer core normalizes and brands them here.
-     */
-    initNewBlock: (blockId: EditorBlockId, baseline: DraftBlockBaselineInput, meta: DraftBlockInitMetaInput) => void;
-    updateBlockBaseline: (blockId: EditorBlockId, baseline: DraftBlockBaselineInput, meta?: DraftBlockBaselineUpdateMetaInput) => void;
-    setBlockPublishedBaselinesFromBlocks: (blocks: readonly BlockPublishedBaselineInput[]) => void;
-    edit: (blockId: EditorBlockId, content: Record<string, unknown> | null) => void;
-    remove: (blockId: EditorBlockId) => void;
-    clearError: (blockId: EditorBlockId) => void;
-    setPending: (blockId: EditorBlockId) => void;
-    clearPending: (blockId: EditorBlockId) => void;
-    setFailed: (blockId: EditorBlockId, message?: string) => void;
-    autosaveSucceeded: (blockId: EditorBlockId, content: Record<string, unknown> | null, acknowledgement?: AutosaveAcknowledgement) => void;
-    autosaveFailed: (blockId: EditorBlockId, message?: string) => void;
-    setAtPath: (blockId: EditorBlockId, path: string, value: unknown) => void;
-    getAtPath: <T = unknown>(blockId: EditorBlockId, path: string) => T | undefined;
-    updateBlockOrder: (blockIds: EditorBlockId[]) => void;
+/**
+ * Form-facing drafts facade: editor-blocks' `DraftsSlice` contract plus the store-only
+ * publish helpers. Baseline inputs stay unbranded so editor consumers can pass raw
+ * form values; the reducer core normalizes and brands them here.
+ */
+export type DraftsState = DraftsSlice & {
     hasUnpublishedBlockChanges: () => boolean;
     getFirstUnpublishedBlockChange: () => EditorDraftUnpublishedBlockChange | null;
-    markAllBlocksAsPublished: () => void;
     onChange: (listener: (blockId: EditorBlockId) => void) => () => void;
+    /**
+     * Shows `content` as the block's local edit without a history entry: a preview runtime
+     * (customize) drives these values and owns their undo (issue 1553).
+     */
+    editWithoutHistory: (blockId: EditorBlockId, content: Record<string, unknown> | null) => void;
 };
+/** Local edits are refused while the tab can't write (read-only, acquiring or viewing). */
+export type EditorUserOperationOutcome = 'applied' | 'unchanged' | 'refused';
+export type EditorPublishedVersionScope = 'metadata' | 'content';
 export type CreateEditorUiStoreOptions = Readonly<{
+    publishedVersionScope?: EditorPublishedVersionScope;
+    contentOwnerEntryId?: string;
+    /** Required so a new caller can't write freely by omission; unmanaged surfaces say so explicitly. */
+    editability: EditorLeaseUiState['editability'];
     resolveBlockManifest?: ResolveBlockManifest;
+    resolveBlockFieldExtensions?: () => BlockFieldExtensions | null | undefined;
 }>;
 type RestoreListener = (transition: {
     previous: EditorHistorySnapshot;
     next: EditorHistorySnapshot;
     effects: readonly EditorEffect[];
 }) => void;
-export type ApplyPublishSuccessTransitionInput = Readonly<{
-    metadata: Readonly<{
-        baseline: Record<string, unknown> | null;
-        current: Record<string, unknown> | null;
-        published: Record<string, unknown> | null;
-    }>;
-    content: Readonly<{
-        published: Record<string, unknown> | null;
-        versionAtPublishStart: number;
-    }>;
-    blockPublishedBaselines: readonly BlockPublishedBaselineInput[] | null;
-}>;
-export type EditorUiState = {
+export type ApplyPublishSuccessTransitionInput = PublishSuccessRefresh;
+export type EditorUiState = EditorLeaseUiState & LinkedEntryLeaseState & RemoteDraftsState & LinkedSaveHandoversState & {
+    contentOwnerEntryId: string | undefined;
     drawerOpen: boolean;
     previewSidebarTab: PreviewSidebarTab;
     previewInspection: PreviewInspection;
@@ -222,9 +224,36 @@ export type EditorUiState = {
     clearFocus: () => void;
     setActiveBlockId: (id: EditorBlockId | null) => void;
     getDraftSyncState: () => 'baseline' | 'pending' | 'failed';
+    /** The document's lifecycle operations (`LifecycleOperation`); outside history, beside the values' states. */
+    lifecycle: LifecycleStatus;
+    /** When a save or lifecycle operation was last accepted (ISO time). */
+    lastSavedAt: string | null;
+    /** How many saves have been accepted; a `server` lifecycle failure holds until this moves. */
+    acceptedSaves: number;
+    setLifecycle: (change: LifecycleChange) => void;
+    /**
+     * Starts a save for each value that may send now, allocating one id per request.
+     * Returns what each started request carries; values that may not send are left out.
+     */
+    beginSends: (keys: readonly EditorValueKey[], mode?: SendMode, checkpoints?: ReadonlyMap<string, Record<string, unknown> | null>) => readonly StartedSend[];
+    /** One value's sync state; `undefined` when that block or linked entry isn't loaded. */
+    getValueSync: (key: EditorValueKey) => ValueSync<EditorValueRecord | null> | undefined;
+    /** Applies a response. Only the value's current request is acknowledged; others are ignored. */
+    settle: (key: EditorValueKey, id: SendId, result: SendResult) => ValueSyncOutcome;
+    /** Throws away every unsaved local edit, synchronously; see `discardLocalEditsSnapshot`. */
+    discardLocalEdits: () => void;
     getUnpublishedState: () => EditorUnpublishedState;
     hasAnyUnpublishedChanges: () => boolean;
+    applyDocumentLifecycle: (result: DocumentLifecycleResult) => void;
     applyPublishSuccessTransition: (transition: ApplyPublishSuccessTransitionInput) => void;
+    /** Applies what this tab's own writes returned, rebased under any edits (`OwnWrite`). */
+    applyOwnWrites: (writes: readonly OwnWrite[]) => void;
+    /**
+     * Applies server reads as refresh events in one update, under one policy (issue 1553):
+     * keep-local for ordinary refreshes, take-back for a lease grant, replace for discard
+     * draft. Returns whether local edits were discarded.
+     */
+    refreshValues: (refreshes: readonly ValueRefresh[], policy: RefreshPolicy) => boolean;
     history: {
         getState: () => EditorHistoryState;
         canUndo: () => boolean;
@@ -241,9 +270,16 @@ export type EditorUiState = {
     };
     blockValidation: BlockValidationState;
     structure: {
+        getOwner: () => EditorBlockCollectionOwner | null;
+        mount: (owner: EditorBlockCollectionOwner, blocks: readonly ServerBlockItem[], reads?: readonly EditorBlockCollectionReadBaseline[]) => void;
+        unmount: (owner: EditorBlockCollectionOwner) => void;
         getList: () => readonly NormalizedEditorBlockItem[];
         replaceList: (next: readonly EditorBlockItem[]) => void;
     };
+    blockVersions: BlockVersionsState;
+    admitServerBlocks: (entries: readonly ServerBlockAdmission[], policy?: RefreshPolicy) => void;
+    insertServerBlock: (command: EditorInsertBlockCommand, versions: EditorBlockVersions) => void;
+    remapServerBlock: (fromId: EditorBlockId, toId: EditorBlockId, versions: EditorBlockVersions) => void;
     drafts: DraftsState;
     metadata: MetadataState;
     content: ContentState;
@@ -254,7 +290,25 @@ export type EditorUiState = {
     viewport: ViewportState;
     aiOverlays: AiOverlaysState;
 };
-export declare function createEditorUiStore(options?: CreateEditorUiStoreOptions): import("zustand").StoreApi<EditorUiState>;
+/**
+ * How a lifecycle operation moves the status: it starts, finishes (recording when it
+ * saved, if it did) or fails.
+ */
+export type LifecycleChange = Readonly<{
+    kind: 'start';
+    operation: LifecycleOperation;
+}> | Readonly<{
+    kind: 'hold';
+    operation: HeldOperation;
+}> | Readonly<{
+    kind: 'finish';
+    at: string | null;
+}> | Readonly<{
+    kind: 'fail';
+    operation: LifecycleOperation;
+    failure: LifecycleFailure;
+}>;
+export declare function createEditorUiStore(options: CreateEditorUiStoreOptions): import("zustand").StoreApi<EditorUiState>;
 export type EditorUiStoreInstance = ReturnType<typeof createEditorUiStore>;
 export declare const EditorUiStoreProvider: import("react").Provider<import("zustand").StoreApi<EditorUiState> | null>;
 export declare function useEditorUiStore<T>(selector: (state: EditorUiState) => T): T;

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;