@riverbankcms/sdk 0.147.0 → 0.148.0

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

@@ -0,0 +1,34 @@
+import type { EditAuthority } from '../../../core/src/index';
+import type { EditorEditability } from './editorEditability';
+import type { EditorLeaseConfig } from './EditLeaseController';
+/**
+ * How a mount takes part in the edit lease:
+ * - a lease config: it holds (or asks for) the lease;
+ * - an exemption: it writes without a lease;
+ * - viewing: it is not trying to edit, so it mounts no lease controller at all.
+ */
+export type EditorLeaseParticipation = EditorLeaseConfig | Extract<EditAuthority, {
+    kind: 'exempt';
+}> | EditorViewingParticipation;
+export type EditorViewingParticipation = Readonly<{
+    kind: 'viewing';
+}>;
+export declare const VIEWING_PARTICIPATION: EditorViewingParticipation;
+type ClassifiedParticipation = Readonly<{
+    kind: 'leased';
+    config: EditorLeaseConfig;
+}> | Extract<EditAuthority, {
+    kind: 'exempt';
+}> | EditorViewingParticipation;
+export type LeaseParticipationKind = ClassifiedParticipation['kind'];
+export declare function classifyLeaseParticipation(participation: EditorLeaseParticipation): ClassifiedParticipation;
+export declare function leaseConfigOf(participation: EditorLeaseParticipation): EditorLeaseConfig | null;
+/** Viewing and leased mounts share one store identity, so switching between them keeps local edits. */
+export declare function leaseExemptionOf(participation: EditorLeaseParticipation): "team-member-profile" | "sdk" | null;
+export declare function initialParticipationEditability(participation: EditorLeaseParticipation): EditorEditability;
+/**
+ * The store's editability after the mount's participation changes. A lease controller owns
+ * editability while it is mounted; this only moves the store into and out of `viewing`.
+ */
+export declare function nextParticipationEditability(participation: LeaseParticipationKind, current: EditorEditability): EditorEditability;
+export {};

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

@@ -0,0 +1,29 @@
+import type { ContentRouteRecord } from '../../../api/src/content-editor';
+import { type ContentEntrySnapshot, type RoutingHelpers } from '../../../content-model/src/index';
+/**
+ * A snapshot's metadata values as the editor holds and sends them. A homepage has no
+ * slug (the snapshot's is null); the editor holds that as '', which is what the metadata
+ * endpoints accept, so a whole-record save after a lifecycle write isn't refused.
+ */
+export declare function normalizedMetadataBaseline(entry: ContentEntrySnapshot): Record<string, unknown>;
+/** A document's metadata as the store holds it: its values, published baseline and draft revision. */
+export type DocumentMetadata = Readonly<{
+    values: Record<string, unknown>;
+    published: Record<string, unknown> | null;
+    revision: string | null;
+}>;
+/**
+ * The one mapping from an entry snapshot to the metadata the store holds, for server
+ * props, lease-grant reads and the route rows lifecycle writes return.
+ */
+export declare function snapshotMetadata(snapshot: ContentEntrySnapshot, routing: RoutingHelpers, revision: string | null): DocumentMetadata;
+/** A route row (a write's own result, or a read) as the owning document's metadata. */
+export declare function routeMetadata(documentId: string, route: ContentRouteRecord, routing: RoutingHelpers): DocumentMetadata;
+export declare function routeField(route: Record<string, unknown>, camel: string, snake: string): unknown;
+/**
+ * A metadata save's stored route as the values the editor holds, normalised like
+ * `normalizedMetadataBaseline`: a homepage's stored slug is null, held as ''. Otherwise a
+ * later edit sees the null as a change of its own and sends it, which the metadata
+ * endpoints refuse (issue 1553, found by the discard E2E).
+ */
+export declare function savedRouteMetadataValues(route: Record<string, unknown>): Record<string, unknown>;

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

@@ -0,0 +1,14 @@
+import type { PageSurfaceEditorDocument } from '../../../api/src/content-editor';
+import type { RoutingHelpers } from '../../../content-model/src/index';
+import type { DocumentValueBaseline } from './documentValueBaseline';
+export type PageSurfaceDocumentBaselines = Readonly<{
+    metadata: DocumentValueBaseline;
+    content: DocumentValueBaseline;
+}>;
+/**
+ * The editor baselines a page surface's server document stands for: its
+ * route's draft metadata and its content draft, each with the revision the
+ * next save must quote. Re-reading after a lease grant and applying a discard
+ * both read the document this way, so the two agree with the first load.
+ */
+export declare function pageSurfaceDocumentBaselines(document: PageSurfaceEditorDocument, routing: RoutingHelpers): PageSurfaceDocumentBaselines;

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

@@ -0,0 +1,11 @@
+import type { PublishPageSurfaceResponse } from '../../../api/src/content-editor';
+import type { RoutingHelpers } from '../../../content-model/src/index';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { DocumentSince } from '../sync/runLifecycle';
+import type { DiscardLifecycleResult } from '../services/contentEntryServices';
+import type { ContentEntrySnapshot } from '../../../content-model/src/index';
+/** A native publication follows the same atomic receipt reconciliation as entries. */
+export declare function applyPageSurfacePublish(store: EditorUiStoreInstance, routing: RoutingHelpers | undefined, since: DocumentSince, publication: PublishPageSurfaceResponse): void;
+export declare function applyPageSurfaceDiscard(store: EditorUiStoreInstance, routing: RoutingHelpers | undefined, since: DocumentSince, result: Extract<DiscardLifecycleResult<ContentEntrySnapshot>, {
+    kind: 'serverDocument';
+}>): void;

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

@@ -0,0 +1,19 @@
+import type { EditorBlockVersions } from '../../../core/src/index';
+import type { BlockDraftBaselineSeed } from '../../../editor-blocks/src/index';
+import type { ValueRefresh } from '../ui/editorRefresh';
+import type { DocumentValueBaseline } from './documentValueBaseline';
+export type { DocumentValueBaseline };
+export type FreshDocumentBaselines = Readonly<{
+    metadata: DocumentValueBaseline;
+    content: DocumentValueBaseline | null;
+    blocks: readonly (BlockDraftBaselineSeed & Readonly<{
+        versions: EditorBlockVersions;
+    }>)[];
+}>;
+/**
+ * A fresh read of the whole document as refresh events. The refresh policy (keep-local,
+ * or take-back after a grant) is the reducer's to apply, against each value's local
+ * intent (issue 1553). Only incoming items are refreshed; a block missing from the read
+ * is left alone, as the block seeder does.
+ */
+export declare function planDocumentBaselineRefresh(fresh: FreshDocumentBaselines): readonly ValueRefresh[];

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

@@ -0,0 +1,19 @@
+import type { ApiClient } from '../../../api/src/request';
+import { type ContentTypeSchema } from '../../../content-model/src/index';
+import { type ServerBlockItem } from '../../../editor-blocks/src/index';
+import { type BlockFieldExtensions } from '../../../editor-blocks/src/block-editor/blockDraftBaselineSeed';
+import type { EditLeaseScope } from '../../../core/src/index';
+import type { FreshDocumentBaselines } from './planDocumentBaselineRefresh';
+export type DocumentLeaseReadInput = Readonly<{
+    apiClient: ApiClient;
+    siteId: string;
+    scope: EditLeaseScope;
+    type: string;
+    schema: ContentTypeSchema;
+    blockFieldExtensions?: BlockFieldExtensions | null;
+}>;
+export type DocumentLeaseBaselines = Readonly<{
+    baselines: FreshDocumentBaselines;
+    blocks: readonly ServerBlockItem[];
+}>;
+export declare function readDocumentLeaseBaselines(input: DocumentLeaseReadInput): Promise<DocumentLeaseBaselines>;

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

@@ -0,0 +1,12 @@
+import type { RefreshPolicy } from '../sync/valueSync';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import { type DocumentLeaseReadInput } from './readDocumentLeaseBaselines';
+/**
+ * The grant's authoritative reread (row F8). It waits until no save is outstanding, so
+ * the read sees this tab's own saves, then applies every fresh baseline in one refresh
+ * under the grant's policy. All reads complete before anything changes, and a grant that
+ * was overtaken while it waited or read applies nothing.
+ */
+export declare function refreshDocumentLeaseBaseline(input: DocumentLeaseReadInput & Readonly<{
+    uiStore: EditorUiStoreInstance;
+}>, policy: Extract<RefreshPolicy, 'keep-local' | 'take-back'>, isCurrent: () => boolean): Promise<void>;

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

@@ -0,0 +1,17 @@
+import type { ApiClient } from '../../../api/src/request';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { EditorEditability } from './editorEditability';
+/** Updates a linked entry's own lease session, if it has one. */
+export declare function updateLinkedEntrySession(store: EditorUiStoreInstance, entryId: string, update: Partial<Readonly<{
+    editability: EditorEditability;
+    discarded: boolean;
+}>>): void;
+/**
+ * The linked entry's grant reread: it waits until the entry has no save outstanding, so
+ * the read sees this tab's own save (row F8), then applies the read as one refresh.
+ */
+export declare function refreshLinkedEntry(apiClient: ApiClient, store: EditorUiStoreInstance, scope: Readonly<{
+    siteId: string;
+    type: string;
+    entryId: string;
+}>, takingBack: boolean, isCurrent: () => boolean): Promise<void>;

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

@@ -1,8 +1,8 @@
 import { type EditorPageId, type EditorSiteId } from '../ui/editorHistory';
 import type { EditorEffect, EditorHistorySnapshot } from '../ui/editorHistory';
 import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { LifecycleOutcome } from '../ui/stores/types';
 import type { ApiClient } from '../services';
-import { type EditorEffectDrainResult } from './editorEffectDrain';
 type ReplayRestoredEditorEffectsArgs = Readonly<{
     previous: EditorHistorySnapshot;
     effects: readonly EditorEffect[];
@@ -10,7 +10,6 @@ type ReplayRestoredEditorEffectsArgs = Readonly<{
     siteId: EditorSiteId;
     pageId: EditorPageId;
     uiStore: EditorUiStoreInstance;
-    setErrorMessage: (message: string | null) => void;
 }>;
-export declare function replayRestoredEditorEffects({ previous, effects, apiClient, siteId, pageId, uiStore, setErrorMessage, }: ReplayRestoredEditorEffectsArgs): Promise<EditorEffectDrainResult>;
+export declare function replayRestoredEditorEffects({ previous, effects, apiClient, siteId, pageId, uiStore, }: ReplayRestoredEditorEffectsArgs): Promise<LifecycleOutcome>;
 export {};

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

@@ -0,0 +1,26 @@
+import type { ContentRouteRecord } from '../../../api/src/content-editor';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { LifecycleOutcome } from '../ui/stores/types';
+import { type DocumentSince } from '../sync/runLifecycle';
+import type { DocumentMetadata } from './normalizedMetadataBaseline';
+/** Lifecycle writes a host issues itself: native page-surface publish, schedule and cancel. */
+export type RouteWriteOperation = 'publish' | 'schedule' | 'cancel-schedule';
+/**
+ * Writes whose response is the route row they wrote (issue 1553, A), run through the
+ * document's one lifecycle shell (B-ownership): each settles what its operation settles
+ * first, holds the document while its request is out, and applies its response as this
+ * tab's own write.
+ */
+export type RouteWrites = Readonly<{
+    /** The document metadata a route row holds: values, published baseline and draft revision. */
+    metadataOf: (route: ContentRouteRecord) => DocumentMetadata;
+    /**
+     * Runs such a write under `operation`'s reconciliation; `apply` receives the response
+     * and what the person's edits are measured from. A refusal or rejected request is the
+     * outcome's failure (also the banner's); callers branch on it rather than catching.
+     */
+    run: <T>(operation: RouteWriteOperation, request: () => Promise<T>, apply: (response: T, since: DocumentSince) => void) => Promise<LifecycleOutcome>;
+    /** Applies a route row as this tab's own write: rebased under any edit typed meanwhile (rows R1–R11, WR4). */
+    applyRoute: (route: ContentRouteRecord, since: DocumentSince) => void;
+}>;
+export declare function createRouteWrites(uiStore: EditorUiStoreInstance, metadataOf: RouteWrites['metadataOf']): RouteWrites;

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

@@ -1,29 +1,28 @@
-import type { useStoreAutosave } from '../hooks/useStoreAutosave';
-import type { useBlockAutosave } from '../hooks/useBlockAutosave';
-import type { AutosaveHandle } from '../hooks/useSimpleAutosave';
 import type { createEditorUiStore } from '../ui/editorUiStore';
+import type { AutosaveHandle, AutosaveType } from '../ui/stores/types';
+import { type SchedulerValue, type SendSignature } from '../sync/sendPlanning';
+type TriggerHandle = Pick<AutosaveHandle, 'trigger'>;
 type UseAutosaveTriggersProps = {
     uiStore: ReturnType<typeof createEditorUiStore>;
-    metadataAutosave: ReturnType<typeof useStoreAutosave>;
-    blockAutosave: ReturnType<typeof useBlockAutosave>;
-    linkedEntryAutosave?: AutosaveHandle | null;
+    metadataAutosave: TriggerHandle;
+    blockAutosave: TriggerHandle;
+    linkedEntryAutosave?: TriggerHandle | null;
     /** Content autosave - only provided for content entries (not pages) */
-    contentAutosave?: ReturnType<typeof useStoreAutosave> | null;
+    contentAutosave?: TriggerHandle | null;
     hasRoute: boolean;
     /** When false, does not trigger background autosaves (manual-save mode). */
     enableTriggers?: boolean;
 };
+type SignatureMemory = Readonly<Record<AutosaveType, SendSignature>>;
 /**
- * Hook that orchestrates autosave triggering based on draft state changes.
- *
- * Uses VERSION-BASED TRIGGERING to handle continuous editing correctly:
- * - Metadata: Triggers when status='pending' AND version changed
- * - Content: Triggers when status='pending' AND version changed (content entries only)
- * - Blocks: Triggers when any block has status='pending' AND version changed
- *
- * This solves the "autosave only fires once" bug that occurred with status
- * transition tracking. When a user continues editing during/after save,
- * status stays 'pending' but version increments, so we still trigger.
+ * Which schedulers are due: those whose send signature changed and isn't empty. The
+ * signature covers edits, a request settling with newer edits and a value becoming
+ * writable again, so each of those starts a save (issue 1553, rows S2, S5, D2).
  */
+export declare function dueSchedulers(previous: SignatureMemory, values: readonly SchedulerValue[]): Readonly<{
+    memory: SignatureMemory;
+    due: readonly AutosaveType[];
+}>;
+/** Starts each scheduler's debounced save when its values may send something new. */
 export declare function useAutosaveTriggers({ uiStore, metadataAutosave, blockAutosave, linkedEntryAutosave, contentAutosave, hasRoute, enableTriggers, }: UseAutosaveTriggersProps): void;
 export {};

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

@@ -1,10 +1,14 @@
-import { type Dispatch, type SetStateAction } from 'react';
 import type { EditorUiStoreInstance } from '../ui/editorUiStore';
 import { type BlockedPublishPlan } from '../hooks/blockedPublishPlan';
 type VisibleBlockedPublishPlan = Extract<BlockedPublishPlan, {
     type: 'blocked';
 }>;
-export declare function useBlockedPublishPlan(uiStore: EditorUiStoreInstance, setErrorMessage: Dispatch<SetStateAction<string | null>>): readonly [
+/**
+ * The publish-blocking plan a refused publish showed, kept current: it's re-derived on
+ * every block change and cleared once validation passes. The error banner reads its
+ * message while the `invalid-blocks` failure holds (row B5).
+ */
+export declare function useBlockedPublishPlan(uiStore: EditorUiStoreInstance): readonly [
     VisibleBlockedPublishPlan | null,
     (plan: VisibleBlockedPublishPlan | null) => void
 ];

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

@@ -1,4 +1,4 @@
-import type { BlockItem } from '../../../editor-blocks/src/block-editor/types';
+import type { BlockItem, ServerBlockItem } from '../../../editor-blocks/src/block-editor/types';
 import type { EditorUiState } from '../ui/editorUiStore';
 import type { ApiClient } from '../services';
 type StoreApi<T> = {
@@ -11,10 +11,10 @@ export declare function useBlocksList({ apiClient, uiStore, siteId, entryId, isP
     siteId: string;
     entryId: string;
     isPage: boolean;
-    initialBlocks: BlockItem[];
+    initialBlocks: ServerBlockItem[];
 }): {
     blocksSlice: {
-        list: BlockItem[];
+        list: import("../ui/editorSnapshot").NormalizedEditorBlockItem[];
         status: "idle";
         actions: {
             setList: (next: BlockItem[]) => void;

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

@@ -0,0 +1,21 @@
+import type { ContentEditorServices } from '../services';
+import type { PublishPageSurfaceResponse } from '../../../api/src/content-editor';
+import type { RoutingHelpers } from '../../../content-model/src/index';
+import type { EditorUiStoreInstance } from '../ui/editorUiStore';
+import type { AutosaveHandle } from '../ui/stores/types';
+type ValueAutosaveInput = Readonly<{
+    services: ContentEditorServices;
+    uiStore: EditorUiStoreInstance;
+    delay: number;
+    routing?: RoutingHelpers;
+    onPublication?: (publication: Extract<PublishPageSurfaceResponse, {
+        publication: 'published';
+    }>) => void;
+}>;
+export declare function useEntryValueAutosaves(input: ValueAutosaveInput & {
+    isPage: boolean;
+}): {
+    metadataAutosave: AutosaveHandle;
+    contentAutosave: AutosaveHandle;
+};
+export {};

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;