@riverbankcms/sdk 0.146.0 → 0.148.0

package/dist/_dts/content-editor/src/controller/useInitialEditorUiStore.d.ts

@@ -0,0 +1,24 @@
+import type { BlockFieldExtensions } from '../../../editor-blocks/src/block-editor/blockDraftBaselineSeed';
+import { type ContentEntrySnapshot, type RoutingHelpers } from '../../../content-model/src/index';
+import { type EditorPublishedVersionScope } from '../ui/editorUiStore';
+import type { ResolveBlockManifest } from '../ui/blockValidationView';
+import { type EditorLeaseParticipation } from './editorLeaseParticipation';
+import type { ServerBlockItem } from '../../../editor-blocks/src/block-editor/types';
+type InitialEditorUiStoreOptions = Readonly<{
+    entry: ContentEntrySnapshot;
+    routing: RoutingHelpers;
+    hasRoute: boolean;
+    isPage: boolean;
+    publishedVersionScope: EditorPublishedVersionScope;
+    initialMetadataRevision: string | null;
+    resolveBlockManifest?: ResolveBlockManifest;
+    blockFieldExtensions?: BlockFieldExtensions | null;
+    initialBlocks: readonly ServerBlockItem[];
+    editLease: EditorLeaseParticipation;
+}>;
+/** Own store identity and synchronous metadata hydration together. */
+export declare function useInitialEditorUiStore({ entry, routing, hasRoute, isPage, publishedVersionScope, initialMetadataRevision, resolveBlockManifest, editLease, blockFieldExtensions, initialBlocks, }: InitialEditorUiStoreOptions): {
+    uiStore: import("zustand").StoreApi<import("..").EditorUiState>;
+    hasHydratedContentRef: import("react").RefObject<boolean>;
+};
+export {};

package/dist/_dts/content-editor/src/controller/useServerBaselineReconciliation.d.ts

@@ -0,0 +1,17 @@
+import { type RefObject } from 'react';
+import type { ContentEntrySnapshot, RoutingHelpers } from '../../../content-model/src/index';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+export declare function useMetadataReconciliation(input: Readonly<{
+    initialEntry?: ContentEntrySnapshot | null;
+    revision?: string | null;
+    routing: RoutingHelpers;
+    uiStore: EditorUiStoreInstance;
+}>): void;
+export declare function useContentReconciliation(input: Readonly<{
+    isPage: boolean;
+    initialContent?: Record<string, unknown> | null;
+    published?: Record<string, unknown> | null;
+    revision?: string | null;
+    hydratedRef: RefObject<boolean>;
+    uiStore: EditorUiStoreInstance;
+}>): void;

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

@@ -3,7 +3,7 @@ import type { ApiClient } from '../../api/src/request';
 import type { FooterEditorTarget } from './footerComposer';
 import type { FooterNavigationLayoutAccess } from './useFooterNavigationLayout';
 export type FooterComposerPanelProps = Readonly<{
-    apiClient: ApiClient;
+    apiClient: ApiClient<'getFooterComposition' | 'updateFooterComposition' | 'getPublicProfile' | 'updatePublicProfile' | 'getNavigationMenus' | 'getMailingListAuthoringContext' | 'listForms' | 'applySiteStyleSelection'>;
     siteId: string;
     customFooterMode: 'default' | 'blocks' | 'default+blocks' | 'none';
     manageLinksHref: string;

package/dist/_dts/content-editor/src/hooks/applyBlockedPublishPlan.d.ts

@@ -1,5 +1,9 @@
 import type { EditorUiStoreInstance } from '../ui/editorUiStore';
 import { type BlockedPublishPlan } from "./blockedPublishPlan";
+/**
+ * Reveals and focuses what blocks publishing. The banner's message isn't set here: it
+ * derives from the recorded `invalid-blocks` failure and the current validation.
+ */
 export declare function applyBlockedPublishPlan(uiStore: EditorUiStoreInstance, plan: Extract<BlockedPublishPlan, {
     type: "blocked";
-}>, setErrorMessage: (message: string | null) => void): void;
+}>): void;

package/dist/_dts/content-editor/src/hooks/blockDraftLifecycle.d.ts

@@ -1,48 +1,9 @@
 import type { BlockDraftSaveability } from "../../../block-form/src/blockDraftSaveability";
-import type { EditorBlockId } from "../../../core/src/index";
-import type { AutosaveStatusValue } from "../ui/stores/types";
-import type { EditorDraftSnapshot } from "../ui/editorHistory";
-type CurrentEditorDraftSnapshot = EditorDraftSnapshot & {
-    current: NonNullable<EditorDraftSnapshot["current"]>;
-};
-export type BlockDraftLifecycle = Readonly<{
-    kind: "baseline";
-    blockId: EditorBlockId;
-}> | Readonly<{
-    kind: "validPending";
-    blockId: EditorBlockId;
-    version: number;
-}> | Readonly<{
-    kind: "invalidPending";
-    blockId: EditorBlockId;
-    issues: BlockDraftSaveability["issues"];
-}> | Readonly<{
-    kind: "saving";
-    blockId: EditorBlockId;
-    version: number;
-}> | Readonly<{
-    kind: "saveFailed";
-    blockId: EditorBlockId;
-    error: string;
-    issues: BlockDraftSaveability["issues"];
-}>;
-export type BlockDraftAutosaveDecision = Readonly<{
-    type: "save";
-    blockId: EditorBlockId;
-    data: Record<string, unknown>;
-    acknowledgedVersion: number;
-}> | Readonly<{
-    type: "skip";
-    blockId: EditorBlockId;
-    reason: "baseline" | "invalid" | "saving" | "saveFailed";
-}>;
-export declare function deriveBlockDraftLifecycle(input: Readonly<{
-    snapshot: EditorDraftSnapshot;
-    saveability: BlockDraftSaveability;
-    autosaveStatus?: AutosaveStatusValue;
-}>): BlockDraftLifecycle;
-export declare function deriveBlockDraftAutosaveDecision(input: Readonly<{
-    snapshot: CurrentEditorDraftSnapshot;
-    lifecycle: BlockDraftLifecycle;
-}>): BlockDraftAutosaveDecision;
-export {};
+/**
+ * Whether a block's values may be sent: validation found nothing blocking. A failed save
+ * with no validation issues is saveable again; whether it is retried now is `canSend`'s
+ * rule (issue 1553, rows S3 and S3b).
+ */
+export declare function isBlockSaveable(saveability: BlockDraftSaveability): boolean;
+/** The payload a block save sends: its values, unwrapped from a `data` envelope if present. */
+export declare function blockSaveData(values: Record<string, unknown> | null): Record<string, unknown>;

package/dist/_dts/content-editor/src/hooks/editLeaseMachine.d.ts

@@ -0,0 +1,120 @@
+import type { EditLeaseAcquireResult, EditLeaseToken, EditLeaseView } from '../../../core/src/index';
+import type { EditorEditability } from '../controller/editorEditability';
+export type LeaseFailure = 'unavailable' | 'invalid' | 'required' | 'forbidden' | 'not-found';
+type Phase = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'suspended';
+}> | Readonly<{
+    kind: 'requesting';
+    id: number;
+    takingBack: boolean;
+}> | Readonly<{
+    kind: 'refreshing' | 'confirming';
+    id: number;
+    takingBack: boolean;
+    token: EditLeaseToken;
+}> | Readonly<{
+    kind: 'checking';
+    id: number;
+    takingBack: boolean;
+    priorToken: EditLeaseToken | null;
+    showing: Extract<EditorEditability, {
+        kind: 'read-only';
+    }> | null;
+}> | Readonly<{
+    kind: 'editable';
+    id: number;
+    token: EditLeaseToken;
+    failures: number;
+}> | Readonly<{
+    kind: 'held';
+    holder: Extract<EditLeaseView, {
+        kind: 'held-elsewhere';
+    }>['holder'];
+}> | Readonly<{
+    kind: 'unavailable';
+}> | Readonly<{
+    kind: 'fault';
+    reason: LeaseFailure;
+}> | Readonly<{
+    kind: 'closed';
+}>;
+export type LeaseMachine = Readonly<{
+    phase: Phase;
+    nextId: number;
+}>;
+export type LeaseEvent = Readonly<{
+    kind: 'acquire';
+    takeover: boolean;
+}> | Readonly<{
+    kind: 'recheck';
+}> | Readonly<{
+    kind: 'lease-lost';
+}> | Readonly<{
+    kind: 'grant';
+    id: number;
+    result: EditLeaseAcquireResult | LeaseFailure;
+}> | Readonly<{
+    kind: 'view';
+    id: number;
+    result: EditLeaseView | LeaseFailure;
+}> | Readonly<{
+    kind: 'refreshed';
+    id: number;
+    success: boolean;
+}> | Readonly<{
+    kind: 'confirmed';
+    id: number;
+    result: 'mine' | LeaseFailure | 'lost';
+}> | Readonly<{
+    kind: 'heartbeat';
+    id: number;
+    result: 'mine' | LeaseFailure | 'lost';
+}> | Readonly<{
+    kind: 'tick';
+}> | Readonly<{
+    kind: 'suspend';
+}> | Readonly<{
+    kind: 'stop';
+}>;
+export type LeaseEffect = Readonly<{
+    kind: 'clear-discarded';
+}> | Readonly<{
+    kind: 'request';
+    id: number;
+    takeover: boolean;
+}> | Readonly<{
+    kind: 'read';
+    id: number;
+}> | Readonly<{
+    kind: 'refresh';
+    id: number;
+    takingBack: boolean;
+}> | Readonly<{
+    kind: 'confirm';
+    id: number;
+    token: EditLeaseToken;
+}> | Readonly<{
+    kind: 'heartbeat';
+    id: number;
+    token: EditLeaseToken;
+}> | Readonly<{
+    kind: 'release';
+    token: EditLeaseToken;
+}> | Readonly<{
+    kind: 'fault';
+    reason: LeaseFailure;
+}>;
+export type LeaseStep = Readonly<{
+    state: LeaseMachine;
+    effects: readonly LeaseEffect[];
+}>;
+export declare function initialLeaseMachine(): LeaseMachine;
+export declare function stepLease(state: LeaseMachine, event: LeaseEvent): LeaseStep;
+/**
+ * The store editability a lease phase implies. A stopped session (`closed`) implies none:
+ * it no longer owns the store, so the host decides (preview hands it back to viewing).
+ */
+export declare function leaseEditability(state: LeaseMachine): EditorEditability | null;
+export {};

package/dist/_dts/content-editor/src/hooks/publishability.d.ts

@@ -1,8 +1,7 @@
-import type { AutosaveStatus } from "../ui/stores/types";
 import type { EditorUnpublishedState } from "../controller/deriveEditorUnpublishedState";
 import { type BlockedPublishPlan } from "./blockedPublishPlan";
 import type { BlockValidationError } from "./validateBlocksForPublish";
-export type PublishDisabledReason = "noUnpublishedChanges" | "invalidBlocks" | "invalidBlockSummary" | "autosaveFailed";
+export type PublishDisabledReason = "noUnpublishedChanges" | "invalidBlocks" | "invalidBlockSummary";
 export type PublishabilityPlan = Readonly<{
     kind: "allowed";
     canPublish: true;
@@ -27,12 +26,6 @@ export type PublishabilityPlan = Readonly<{
         type: "allowed";
     }>;
 }>;
-export type PublishabilityAutosaveState = Readonly<{
-    metadata: AutosaveStatus;
-    content: AutosaveStatus;
-    blocks: AutosaveStatus;
-    linkedEntries: AutosaveStatus;
-}>;
 export type DerivePublishabilityInput = Readonly<{
     unpublishedState: EditorUnpublishedState;
     validationErrors: readonly BlockValidationError[];
@@ -42,7 +35,10 @@ export type DerivePublishabilityInput = Readonly<{
      */
     hasInvalidBlockSummary?: boolean;
     drawerOpen: boolean;
-    autosave?: PublishabilityAutosaveState;
-    includeAutosaveFailures?: boolean;
 }>;
+/**
+ * Block validation, focus and whether there's anything to publish. Whether the values
+ * can be saved first is the publish flush plan's decision (`selectPublishFlushPlan`),
+ * for the action and the toolbar alike (issue 1553, rows Q1–Q3).
+ */
 export declare function derivePublishability(input: DerivePublishabilityInput): PublishabilityPlan;

package/dist/_dts/content-editor/src/hooks/useAutosaveStatus.d.ts

@@ -0,0 +1,3 @@
+import type { AutosaveStatus, AutosaveType } from '../ui/stores/types';
+/** The derived autosave status for one scheduler, or the whole document when none is given. */
+export declare function useAutosaveStatus(scheduler?: AutosaveType): AutosaveStatus;

package/dist/_dts/content-editor/src/hooks/useBlockAutosave.d.ts

@@ -10,28 +10,18 @@ export type BlockAutosaveOptions = {
     siteId: string;
     /** Whether this entry has a route (pages have blocks, content entries don't) */
     hasRoute: boolean;
-    owner: BlockAutosaveOwner;
     getExpectedMailingListProviderScope?: () => MailingListProviderScope | null;
 };
-export type BlockAutosaveOwner = Readonly<{
-    kind: 'contentEntry';
-}> | Readonly<{
-    kind: 'pageSurface';
-}>;
 export type BlockSaveRevisionPlan = Readonly<{
-    kind: 'bestEffort';
-    optimisticHash: string | null;
-}> | Readonly<{
     kind: 'compareAndSet';
     optimisticHash: string;
 }> | Readonly<{
     kind: 'missingRequiredRevision';
 }>;
-export declare function planBlockSaveRevisionForOwner(owner: BlockAutosaveOwner, optimisticHash: string | null): BlockSaveRevisionPlan;
+export declare function planBlockSaveRevision(optimisticHash: string | null): BlockSaveRevisionPlan;
 /**
- * Hook to handle block autosave for pages.
- * Watches for pending block changes and debounces saves to the server.
- *
- * Only enabled for pages (hasRoute=true), as content entries don't have blocks.
+ * Block autosave for pages: the block family's adapter for `useValueAutosave`. Each
+ * block's request carries its own id, so one failure in a batch fails only that block
+ * (row K1). Only enabled for pages (hasRoute=true), as content entries don't have blocks.
  */
-export declare function useBlockAutosave({ uiStore, apiClient, siteId, hasRoute, owner, getExpectedMailingListProviderScope, }: BlockAutosaveOptions): import("./useSimpleAutosave").AutosaveHandle;
+export declare function useBlockAutosave({ uiStore, apiClient, siteId, hasRoute, getExpectedMailingListProviderScope, }: BlockAutosaveOptions): import("../ui/editorUiStore").AutosaveHandle;

package/dist/_dts/content-editor/src/hooks/useDebouncedLatestSave.d.ts

@@ -1,12 +1,14 @@
-export type DebouncedLatestSaveHandle = {
+export type DebouncedLatestSaveHandle<TResult = void, TSnapshot = unknown> = {
     trigger: () => void;
     cancel: () => void;
-    flush: () => Promise<void>;
+    flush: () => Promise<TResult | undefined>;
     isPending: () => boolean;
+    whenIdle: () => Promise<TResult | undefined>;
+    run: (snapshot: TSnapshot) => Promise<TResult | undefined>;
 };
 export type DebouncedLatestSaveConfig<TSnapshot, TPayload, TResult> = {
     getSnapshot: () => TSnapshot;
-    buildPayload: (snapshot: TSnapshot) => TPayload | null | undefined;
+    buildPayload: (snapshot: TSnapshot, preceding?: TResult) => TPayload | null | undefined;
     save: (payload: TPayload) => Promise<TResult>;
     shouldSkip?: (snapshot: TSnapshot) => boolean;
     onSaving?: (snapshot: TSnapshot) => void;
@@ -19,6 +21,6 @@ export type DebouncedLatestSaveConfig<TSnapshot, TPayload, TResult> = {
     delay?: number;
     maxWait?: number;
     enabled?: boolean;
-    retryDelay?: number;
 };
-export declare function useDebouncedLatestSave<TSnapshot, TPayload, TResult>(config: DebouncedLatestSaveConfig<TSnapshot, TPayload, TResult>): DebouncedLatestSaveHandle;
+/** Timing and serial execution only. Request identity and save eligibility remain in the value store. */
+export declare function useDebouncedLatestSave<TSnapshot, TPayload, TResult>(config: DebouncedLatestSaveConfig<TSnapshot, TPayload, TResult>): DebouncedLatestSaveHandle<TResult, TSnapshot>;

package/dist/_dts/content-editor/src/hooks/useEditLease.d.ts

@@ -0,0 +1,28 @@
+import type { ApiClient } from '../../../api/src/request';
+import type { EditLeaseScope } from '../../../core/src/index';
+import type { EditorLeaseUiState } from '../ui/editorLeaseUiState';
+type LeaseUiPort = Readonly<{
+    getState: () => Pick<EditorLeaseUiState, 'setEditability' | 'setLeaseDiscardedChanges'>;
+}>;
+import type { EditLeaseLossSignal } from '../controller/editLeaseLossSignal';
+type LeaseParams = Readonly<{
+    siteId: string;
+    nodeType: EditLeaseScope['nodeType'];
+    nodeId: string;
+}>;
+export type EditLeaseChangeSubscription = (scope: Pick<LeaseParams, 'nodeType' | 'nodeId'>, listener: () => void) => () => void;
+export type UseEditLeaseOptions = Readonly<{
+    scope: LeaseParams;
+    apiClient: ApiClient;
+    uiStore: LeaseUiPort;
+    subscribeToLeaseChanges?: EditLeaseChangeSubscription;
+    onGranted?: (takingBack: boolean, isCurrent: () => boolean) => Promise<void> | void;
+    onAccessChanged?: () => void;
+    leaseLossSignal: EditLeaseLossSignal;
+}>;
+export declare function useEditLease({ scope, apiClient, uiStore, subscribeToLeaseChanges, onGranted, onAccessChanged, leaseLossSignal, }: UseEditLeaseOptions): {
+    takeOver: () => void;
+    retry: () => void;
+    recheck: () => void;
+};
+export {};

package/dist/_dts/content-editor/src/hooks/useEntryActions.d.ts

@@ -1,65 +1,51 @@
 import { type ContentEntrySnapshot, type RoutingHelpers } from '../../../content-model/src/index';
 import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { LifecycleOutcome } from '../ui/stores/types';
 import type { BlockedPublishPlan } from './blockedPublishPlan';
-import type { PublishEntryResult } from '../services/contentEntryServices';
-/** Services interface for entry operations */
-export type EntryServices = {
-    deleteEntry?: () => Promise<void>;
-};
-export type PublishOptions = {
-    mode?: 'default' | 'now';
-};
-/** Definition with services */
-export type EntryDefinition = {
-    services: EntryServices;
-    publish?: {
-        buildPayload?: (values: Record<string, unknown>, entry: ContentEntrySnapshot) => unknown;
-    };
-};
+import type { DiscardDraftInput, DiscardLifecycleResult, EditorDeletion, PublishLifecycleResult } from '../services/contentEntryServices';
+export type PublishOptions = Readonly<{
+    whenUnchanged?: 'publish' | 'skip';
+}>;
+export type EntryActions = Readonly<{
+    saveDraft: () => Promise<LifecycleOutcome>;
+    publish: (options?: PublishOptions) => Promise<LifecycleOutcome>;
+    discardDraft: () => Promise<LifecycleOutcome>;
+    deletion: Readonly<{
+        kind: 'deletable';
+        deleteEntry: () => Promise<LifecycleOutcome>;
+    }> | Readonly<{
+        kind: 'deletedWithOwner';
+    }>;
+}>;
 export type EntryActionsOptions<TEntry extends ContentEntrySnapshot> = {
     /** Current entry snapshot */
     entry: TEntry;
     /** UI store instance (to read latest metadata values at call time) */
     uiStore: EditorUiStoreInstance;
-    /** Whether this entry has a route (pages vs content) */
-    hasRoute: boolean;
     /** Routing helpers (for routable published baseline derivations). */
     routing?: RoutingHelpers;
     /** Publish mutation from react-query */
     publishMutation: {
-        mutateAsync: (payload?: unknown) => Promise<PublishEntryResult<TEntry>>;
+        mutateAsync: () => Promise<PublishLifecycleResult<TEntry>>;
     };
     /** Discard draft mutation from react-query */
     discardMutation: {
-        mutateAsync: () => Promise<TEntry>;
+        mutateAsync: (input: DiscardDraftInput) => Promise<DiscardLifecycleResult<TEntry>>;
     };
     /** Entry definition with services */
-    definition: EntryDefinition;
-    /** Function to sync entry and create snapshot */
-    syncEntry: (nextEntry: TEntry, opts?: {
-        clearError?: boolean;
-    }) => {
+    deletion: EditorDeletion;
+    /** The metadata values an entry snapshot holds, as the store holds them (`normalizedMetadataBaseline`). */
+    metadataOf: (nextEntry: TEntry) => {
         baseline: Record<string, unknown>;
         values: Record<string, unknown>;
     };
-    /** Function to reset form from snapshot */
-    resetFromSnapshot: (snapshot: {
-        baseline: Record<string, unknown>;
-        values: Record<string, unknown>;
-    }) => void;
-    /** Function to set error message */
-    setErrorMessage: (message: string | null) => void;
     setBlockedPublishPlan?: (plan: Extract<BlockedPublishPlan, {
         type: 'blocked';
     }> | null) => void;
 };
 /**
- * Hook to handle entry actions (publish, discard, delete).
- * Extracts action handler logic from the provider for better separation of concerns.
+ * Hook to handle entry actions (save draft, publish, discard, delete). Each returns a
+ * `LifecycleOutcome`; expected refusals are results, and the error banner and status
+ * derive from the lifecycle failure it records (issue 1553).
  */
-export declare function useEntryActions<TEntry extends ContentEntrySnapshot>({ entry, uiStore, hasRoute, routing, publishMutation, discardMutation, definition, syncEntry, resetFromSnapshot, setErrorMessage, setBlockedPublishPlan: setBlockedPlan, }: EntryActionsOptions<TEntry>): {
-    saveDraft: () => Promise<void>;
-    publish: (options?: PublishOptions) => Promise<void>;
-    discardDraft: () => Promise<void>;
-    deleteEntry: () => Promise<void>;
-};
+export declare function useEntryActions<TEntry extends ContentEntrySnapshot>({ entry, uiStore, routing, publishMutation, discardMutation, deletion, metadataOf, setBlockedPublishPlan: setBlockedPlan, }: EntryActionsOptions<TEntry>): EntryActions;

package/dist/_dts/content-editor/src/hooks/useEntryMutations.d.ts

@@ -1,28 +1,26 @@
+import { useQueryClient } from '@tanstack/react-query';
 import type { ContentEntrySnapshot } from '../../../content-model/src/index';
-import type { EditorUiState } from '../ui/editorUiStore';
-import type { PublishEntryResult } from '../services/contentEntryServices';
-type StoreApi<T> = {
-    getState: () => T;
+import type { DocumentBlockState } from '@riverbankcms/api/content-entries';
+import type { DiscardDraftInput, DiscardLifecycleResult, PublishLifecycleResult } from '../services/contentEntryServices';
+type BlockCacheContext = {
+    queryClient: ReturnType<typeof useQueryClient>;
+    siteId: string;
+    type: string;
+    entryId: string;
 };
-export declare function usePublishEntryMutation<TEntry extends ContentEntrySnapshot = ContentEntrySnapshot, TPublishPayload = unknown>({ publishFn, siteId, type, entryId, isPage, pageId, uiStore, }: {
-    publishFn?: (payload: TPublishPayload | undefined) => Promise<PublishEntryResult<TEntry>>;
+export declare function reconcileBlockCache(context: BlockCacheContext, state: DocumentBlockState): void;
+export declare function usePublishEntryMutation<TEntry extends ContentEntrySnapshot = ContentEntrySnapshot>({ publishFn, siteId, type, entryId, }: {
+    publishFn?: () => Promise<PublishLifecycleResult<TEntry>>;
     siteId: string;
     type: string;
     entryId: string;
-    isPage?: boolean;
-    pageId?: string;
-    uiStore?: StoreApi<EditorUiState>;
-}): import("@tanstack/react-query").UseMutationResult<Readonly<{
-    snapshot: TEntry;
-    publishedContent?: Record<string, unknown> | null;
-    publishedBlocks?: readonly import("../../../api/src/index").PublishedBlockBaseline[];
-}>, Error, TPublishPayload | undefined, unknown>;
-export declare function useDiscardDraftMutation<TEntry = unknown>({ discardFn, siteId, type, entryId, isPage, pageId, }: {
-    discardFn?: () => Promise<TEntry>;
+}): import("@tanstack/react-query").UseMutationResult<PublishLifecycleResult<TEntry>, Error, void, unknown>;
+export declare function useDiscardDraftMutation<TEntry extends ContentEntrySnapshot>({ discardFn, siteId, type, entryId, }: {
+    discardFn?: (input: DiscardDraftInput) => Promise<DiscardLifecycleResult<TEntry>>;
     siteId: string;
     type: string;
     entryId: string;
-    isPage?: boolean;
-    pageId?: string;
-}): import("@tanstack/react-query").UseMutationResult<TEntry, Error, void, unknown>;
+}): import("@tanstack/react-query").UseMutationResult<DiscardLifecycleResult<TEntry>, Error, Readonly<{
+    contentRevision: string | null;
+}>, unknown>;
 export {};

package/dist/_dts/content-editor/src/hooks/useLinkedEntryAutosave.d.ts

@@ -1,23 +1,20 @@
-import type { ApiClient } from '../services';
-import type { LinkedContentEntryId, LinkedContentTypeKey } from '../linkedEntries/domain';
+import { type LinkedContentEntryId, type LinkedContentTypeKey } from '../linkedEntries/domain';
 import type { EditorUiStoreInstance } from '../ui/editorUiStore';
 export type PendingLinkedEntrySave = Readonly<{
     entryId: LinkedContentEntryId;
     contentTypeKey: LinkedContentTypeKey;
     content: Record<string, unknown>;
-    optimisticHash: string | null;
-    acknowledgedVersion: number;
+    optimisticHash: string;
 }>;
 export type LinkedEntrySaveResult = Readonly<{
     entryId: LinkedContentEntryId;
     content: Record<string, unknown>;
-    optimisticHash: string | null;
+    optimisticHash: string;
 }>;
 export type LinkedEntryAutosaveOptions = Readonly<{
     uiStore: EditorUiStoreInstance;
-    apiClient: ApiClient;
     siteId: string;
     saveLinkedEntry?: (save: PendingLinkedEntrySave) => Promise<LinkedEntrySaveResult>;
 }>;
-export declare function collectPendingLinkedEntrySaves(uiStore: EditorUiStoreInstance): PendingLinkedEntrySave[];
-export declare function useLinkedEntryAutosave({ uiStore, apiClient, siteId, saveLinkedEntry, }: LinkedEntryAutosaveOptions): import("./useSimpleAutosave").AutosaveHandle;
+/** Linked-entry autosave: the linked-entry family's adapter for `useValueAutosave`. */
+export declare function useLinkedEntryAutosave(options: LinkedEntryAutosaveOptions): import("../ui/editorUiStore").AutosaveHandle;

package/dist/_dts/content-editor/src/hooks/useValueAutosave.d.ts

@@ -0,0 +1,64 @@
+import type { BaselineRevision, SaveFailure, SavedBlockContentVersion } from '../../../core/src/index';
+import type { EditorUiState, EditorUiStoreInstance, EditorValueKey, StartedSend } from '../ui/editorUiStore';
+import type { AutosaveHandle, AutosaveType } from '../ui/stores/types';
+import { type FlushCheckpoint, type SendAcknowledgement } from '../sync/sendPlanning';
+import type { SendMode } from '../sync/valueSync';
+/** What the server stored for one request. */
+export type SavedValue = Readonly<{
+    blockVersion?: SavedBlockContentVersion;
+    values: Record<string, unknown> | null;
+    revision: BaselineRevision;
+    published?: Readonly<{
+        kind: 'known';
+        values: Record<string, unknown> | null;
+    } | {
+        kind: 'unknown';
+    }>;
+}>;
+/**
+ * One value family's part of autosave: which scheduler it is, and how one started request
+ * is sent. `send` resolves with what the server stored and throws on failure.
+ */
+export type ValueAutosaveAdapter<TSaved extends SavedValue = SavedValue> = Readonly<{
+    uiStore: EditorUiStoreInstance;
+    scheduler: AutosaveType;
+    send: (send: StartedSend) => Promise<TSaved>;
+    onSaved?: (send: StartedSend, saved: TSaved) => void;
+    enabled?: boolean;
+    delay?: number;
+    maxWait?: number;
+}>;
+/** One batch: the values to send and how a failure among them is treated (`canSend`). */
+export type SendBatch = Readonly<{
+    keys: readonly EditorValueKey[];
+    mode: SendMode;
+    checkpoints?: readonly FlushCheckpoint[];
+    completed?: readonly SendAcknowledgement[];
+    signal?: AbortSignal;
+}>;
+/** A save that can't be compared-and-set: the editor never received the value's revision. */
+export declare function missingRevisionError(): Error;
+/** A send found the tab no longer holds the value's lease before it reached the server. */
+export declare class LeaseLostError extends Error {
+    constructor();
+}
+/** Losing the lease leaves edits unsaved, not failed; they send again once writable (W1). */
+export declare function saveFailureOf(error: unknown): SaveFailure;
+/**
+ * The next batch for a scheduler: what the background would send, plus any values a
+ * flush asked for, which are sent explicitly so a failure is retried (row S3b). A
+ * requested value still has to be writable and saveable now: the lease or a block's
+ * validity can change between the flush's plan and this batch.
+ */
+export declare function nextSendBatch(state: EditorUiState, scheduler: AutosaveType, requested: readonly EditorValueKey[]): SendBatch;
+/**
+ * The whole send effect: start every planned request under its own id, send them
+ * together, and settle each response against its id only.
+ */
+export declare function sendPlanned<TSaved extends SavedValue>(adapter: ValueAutosaveAdapter<TSaved>, batch: SendBatch): Promise<readonly SendAcknowledgement[]>;
+/**
+ * The one autosave hook (issue 1553). `useDebouncedLatestSave` is the timing shell
+ * (debounce, max wait, one batch at a time); the store's request slots say what is
+ * outstanding and `planSends` says what may send.
+ */
+export declare function useValueAutosave<TSaved extends SavedValue>(adapter: ValueAutosaveAdapter<TSaved>): AutosaveHandle;

package/dist/_dts/content-editor/src/hooks/validateBlocksForPublish.d.ts

@@ -1,10 +1,3 @@
-/**
- * Pre-publish validation for blocks.
- *
- * Validates all block content using strict mode validation before allowing publish.
- * This catches empty required fields and other validation errors that were allowed
- * during editing (draft mode) but must be fixed before publishing.
- */
 import type { FieldValidationDescriptor } from '../../../blocks/src/index';
 import type { EditorBlockId } from '../../../core/src/index';
 import type { EditorUiStoreInstance } from '../ui/editorUiStore';