@riverbankcms/sdk 0.147.0 → 0.149.0

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

@@ -1,13 +1,16 @@
 import { type ContentEntrySnapshot, type ContentTypeSchema, type ToolbarState } from '../../../content-model/src/index';
 import type { EditorBlockId, MailingListProviderScope } from '../../../core/src/index';
-import type { BlockItem } from '../../../editor-blocks/src/block-editor/types';
+import type { BlockItem, ServerBlockItem } from '../../../editor-blocks/src/block-editor/types';
 import { type ReactNode } from 'react';
-import { type PublishOptions } from '../hooks/useEntryActions';
-import type { BlockedPublishPlan } from '../hooks/blockedPublishPlan';
-import { type ApiClient, type ContentEditorServices } from '../services';
-import type { DraftWorkflowStatus } from '../types';
+import { type EntryActions } from '../hooks/useEntryActions';
+import { type BlockedPublishPlan } from '../hooks/blockedPublishPlan';
+import { type ContentEntryEditorServices, type PageSurfaceEditorServices } from '../services';
 import { type EditorUiState } from '../ui/editorUiStore';
 import type { ResolveBlockManifest } from '../ui/blockValidationView';
+import { type RouteWrites } from './routeWrites';
+import type { EditorApiClient, EditorApiClientFactory } from '../services/editorApiClient';
+import { type EditorLeaseParticipation } from './editorLeaseParticipation';
+import { type LiveDraftsConfig } from '../liveDrafts/useLiveDrafts';
 export type EntryControllerBlocksSlice = {
     list: BlockItem[];
     status: 'idle' | 'loading' | 'error';
@@ -16,10 +19,6 @@ export type EntryControllerBlocksSlice = {
     };
 };
 export type EntryControllerUiSlice = EditorUiState;
-export type EntryControllerAutosaveState = {
-    status: DraftWorkflowStatus;
-    hasFailedSaves: boolean;
-};
 export type EntryDraftBlockPatch = {
     blockId: EditorBlockId;
     path?: string | null;
@@ -47,18 +46,9 @@ export type EntryRecoveryConflictState = Readonly<{
     reviewAffectedBlocks: () => void;
     discardRecoveredChanges: () => void;
 }>;
-/** Actions returned by useEntryActions */
-export type EntryActions = Readonly<{
-    kind: 'entryLifecycle';
-    saveDraft: () => Promise<void>;
-    publish: (options?: PublishOptions) => Promise<void>;
-    discardDraft: () => Promise<void>;
-    deleteEntry: () => Promise<void>;
-}> | Readonly<{
-    kind: 'pageSurfaceDraft';
-    saveDraft: () => Promise<void>;
-}>;
+export type { EntryActions };
 export type EntryControllerContextValue = {
+    apiClient: EditorApiClient;
     entry: ContentEntrySnapshot;
     baseline: Record<string, unknown>;
     errorMessage: string | null;
@@ -66,21 +56,25 @@ export type EntryControllerContextValue = {
         type: 'blocked';
     }> | null;
     recoveryConflict: EntryRecoveryConflictState | null;
-    setErrorMessage: (msg: string | null) => void;
     actions: EntryActions;
+    /** Writes that return the route row they wrote (native publish, schedule, cancel). */
+    routeWrites: RouteWrites;
     blocks: EntryControllerBlocksSlice;
     drafts: EntryDraftsSlice;
     toolbar: ToolbarState<Record<string, unknown>>;
 };
 type BaseInternalProps = {
     children: ReactNode;
-    apiClient: ApiClient;
+    apiClientFactory: EditorApiClientFactory;
+    /** Viewing mounts no lease controller; switching to a lease config keeps the store and its edits. */
+    editLease: EditorLeaseParticipation;
     siteId: string;
     routeId?: string;
     type: string;
     schema: ContentTypeSchema;
     entityLabel?: string | null;
     initialEntry?: ContentEntrySnapshot | null;
+    initialMetadataRevision: string | null;
     /** Autosave mode (default: auto). Manual disables background autosave triggers. */
     saveMode?: 'auto' | 'manual';
     /** Initial content values for content entries - used to hydrate content store */
@@ -89,34 +83,35 @@ type BaseInternalProps = {
     initialPublishedContent?: Record<string, unknown> | null;
     onEntryUpdated?: (response: unknown) => void;
     historyShortcutsEnabled?: boolean;
+    blockFieldExtensions?: import('../../../editor-blocks/src/block-editor/blockDraftBaselineSeed').BlockFieldExtensions | null;
     resolveBlockManifest?: ResolveBlockManifest;
     getExpectedMailingListProviderScope?: () => MailingListProviderScope | null;
+    /** Live drafts between tabs (issue 1545); omitted where the host has no realtime client. */
+    liveDrafts?: LiveDraftsConfig | null;
 };
 type EditorOwnerServiceProps = Readonly<{
     owner: {
         kind: 'contentEntry';
         contentEntryId: string;
     };
-    services?: Extract<ContentEditorServices, {
-        kind: 'entryLifecycle';
-    }>;
+    services?: ContentEntryEditorServices;
 }> | Readonly<{
     owner: {
         kind: 'pageSurface';
         pageSurfaceId: string;
     };
-    services: Extract<ContentEditorServices, {
-        kind: 'pageSurfaceDraft';
-    }>;
+    services: PageSurfaceEditorServices | ((apiClient: EditorApiClient) => PageSurfaceEditorServices);
 }>;
 type PageInternalProps = {
     kind: 'page';
+    initialContentRevision?: never;
     initialStatus?: 'draft' | 'scheduled' | 'published';
-    initialBlocks?: BlockItem[];
+    initialBlocks?: ServerBlockItem[];
 };
 type ContentInternalProps = {
     kind: 'content';
-    initialBlocks?: BlockItem[];
+    initialContentRevision: string;
+    initialBlocks?: ServerBlockItem[];
 };
 type EntryControllerProviderProps = BaseInternalProps & EditorOwnerServiceProps & (PageInternalProps | ContentInternalProps);
 /**
@@ -137,34 +132,3 @@ type EntryControllerProviderProps = BaseInternalProps & EditorOwnerServiceProps
 export declare function EntryControllerProvider(props: EntryControllerProviderProps): import("react").JSX.Element;
 export declare function useEntryEditorController(): EntryControllerContextValue;
 export declare function useEntryController(): EntryControllerContextValue;
-/**
- * Hook to access autosave status from the uiStore.
- *
- * @deprecated Use useEditorUiStore with selectors instead for better performance:
- * ```tsx
- * const metadataStatus = useEditorUiStore(state => state.autosave.metadata.status)
- * const blocksStatus = useEditorUiStore(state => state.autosave.blocks.status)
- * ```
- *
- * This hook exists for backward compatibility and subscribes to the entire
- * autosave state, causing re-renders when any autosave status changes.
- */
-export declare function useAutosave(): {
-    autosave: import("../ui/editorUiStore").AutosaveStatus;
-    blockAutosave: import("../ui/editorUiStore").AutosaveStatus;
-};
-/**
- * @deprecated Use useEditorUiStore hook directly from '../ui/editorUiStore'
- * This provides granular selector support for better performance.
- *
- * Example:
- * ```tsx
- * // Old (re-renders on any state change):
- * const uiStore = useEntryUiStore()
- *
- * // New (only re-renders when metadata status changes):
- * const metadataStatus = useEditorUiStore(state => state.metadata.getSnapshot().syncState.kind)
- * ```
- */
-export declare function useEntryUiStore(): import("zustand").StoreApi<EditorUiState>;
-export {};

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

@@ -0,0 +1,7 @@
+/**
+ * A linked entry held elsewhere keeps a notice scoped to its panel: it doesn't make the whole
+ * page read-only, so it never raises the page's modal.
+ */
+export declare function LinkedEntryLeaseBanner({ entryId }: Readonly<{
+    entryId: string;
+}>): import("react").JSX.Element | null;

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

@@ -0,0 +1,14 @@
+import type { EditorApiClient, EditorApiClientFactory } from '../services/editorApiClient';
+import { type EditorLeaseConfig } from './EditLeaseController';
+type Props = Readonly<{
+    apiClientFactory: EditorApiClientFactory;
+    parentApiClient: EditorApiClient;
+    lease: EditorLeaseConfig;
+}>;
+/**
+ * A linked entry keeps its lease controller, and so its lease authority, while it's
+ * selected, edited, or has a request in flight or abandoned; it unmounts only once that
+ * request settles (issue 1553, D2 and row L6).
+ */
+export declare function LinkedEntryLeaseControllers(props: Props): import("react").JSX.Element[];
+export {};

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

@@ -18,3 +18,9 @@ export type DeriveEditorUnpublishedStateInput = Readonly<{
     hasBeenPublishedBefore: boolean;
 }>;
 export declare function deriveEditorUnpublishedState(input: DeriveEditorUnpublishedStateInput): EditorUnpublishedState;
+/**
+ * Discard returns a document to its published version, so it needs both
+ * something to discard and a published version to go back to. A document that
+ * has never been published keeps its drafts, and its Discard is unavailable.
+ */
+export declare function canDiscardDraft(state: Pick<EditorUnpublishedState, "hasUnpublishedChanges" | "hasBeenPublishedBefore">): boolean;

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

@@ -0,0 +1,25 @@
+/**
+ * A document value (its metadata or its content) as the server last gave it:
+ * the draft the editor starts from, the published version it compares
+ * against, and the revision the next save is checked with.
+ *
+ * Kept free of imports so the editor services, which also run beside the
+ * server, can describe a discard result without pulling in the block editor.
+ */
+export type DocumentValueBaseline = Readonly<{
+    baseline: Record<string, unknown> | null;
+    published: Record<string, unknown> | null;
+    revision: string | null;
+}>;
+/** Unknown publication evidence retains the existing baseline; known null clears it. */
+export type SavedPublication = Readonly<{
+    kind: 'unknown';
+}> | Readonly<{
+    kind: 'known';
+    values: Record<string, unknown> | null;
+}>;
+export type DocumentSaveReceipt<TRevision extends string | null = string | null> = Readonly<{
+    values: Record<string, unknown>;
+    revision: TRevision;
+    published: SavedPublication;
+}>;

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

@@ -0,0 +1,30 @@
+import { type EditorClientId } from '../../../core/src/index';
+/** After the lease TTL, the departed document's lease has expired anyway. */
+export declare const EDIT_LEASE_HANDOVER_TTL_MS: number;
+export type EditLeaseHandover = Readonly<{
+    clientId: EditorClientId;
+    savedAt: number;
+}>;
+export declare function parseEditLeaseHandover(raw: string | null): EditLeaseHandover | null;
+/** Checked when each acquire is sent, not only when the entry is read. */
+export declare function freshHandover(handover: EditLeaseHandover | null, now: number): EditLeaseHandover | null;
+export type EditLeaseHandoverPort = Readonly<{
+    storage: () => Storage | null;
+    clientId: () => string;
+    now: () => number;
+    onPageTransition: (type: 'pagehide' | 'pageshow', listener: (event: PageTransitionEvent) => void) => void;
+}>;
+export type DocumentEditLeaseHandover = Readonly<{
+    /** Called by each lease session; only documents that edited hand over. */
+    markParticipant: () => void;
+    previousClientIdForAcquire: () => EditorClientId | null;
+}>;
+/**
+ * One handover per document: it's taken once so lease sessions in the document can't
+ * race for it, and it's written from a document listener so it survives the editor
+ * unmounting before the page is left. A document that never edited passes on the
+ * handover it took, unchanged, so editor → other page → editor still hands over.
+ */
+export declare function createDocumentEditLeaseHandover(port: EditLeaseHandoverPort): DocumentEditLeaseHandover;
+export declare function markEditLeaseParticipant(): void;
+export declare function previousEditorClientIdForAcquire(): EditorClientId | null;

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

@@ -0,0 +1,6 @@
+/** Connects save responses to the mounted lease controller without storing protocol state. */
+export declare function createEditLeaseLossSignal(): {
+    emit: () => void;
+    subscribe: (listener: () => void) => () => void;
+};
+export type EditLeaseLossSignal = ReturnType<typeof createEditLeaseLossSignal>;

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

@@ -0,0 +1,28 @@
+import type { EditorEditability } from './editorEditability';
+/**
+ * What a lease notice button does; "Edit here" and "Take over" both take the lease.
+ * `keep-viewing` only returns the tab to view mode; `discard-and-view` throws away the
+ * tab's unsaved edits first, so the label always says what the click does.
+ */
+export type LeaseNoticeAction = 'take-over' | 'retry' | 'discard' | 'keep-viewing' | 'discard-and-view';
+export type LeaseNoticeButton = Readonly<{
+    action: LeaseNoticeAction;
+    label: string;
+}>;
+export type LeaseNotice = Readonly<{
+    variant: 'your-other-tab' | 'another-user' | 'lost-with-unsaved' | 'unreachable';
+    title: string;
+    body: string | null;
+    buttons: readonly LeaseNoticeButton[];
+}>;
+export type LeaseNoticeInput = Readonly<{
+    editability: EditorEditability;
+    /** "this page", "this entry" or "this event page". */
+    thing: string;
+    unsaved: boolean;
+    /** Preview only: the tab can go back to view mode instead. */
+    canKeepViewing: boolean;
+}>;
+/** The blocking notice for a read-only mount, or null when nothing should be said. */
+export declare function planLeaseNotice({ editability, thing, unsaved, canKeepViewing }: LeaseNoticeInput): LeaseNotice | null;
+export declare function leaseDiscardedMessage(thing: string): string;

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

@@ -0,0 +1,2 @@
+/** One id per document, including when a browser duplicates a tab. */
+export declare function getEditorClientId(): string;

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

@@ -0,0 +1,38 @@
+import type { EditAuthority, EditLeaseHolder, EditLeaseToken } from '../../../core/src/index';
+/**
+ * Why a store writes without a lease: a server-side exemption, or a surface the lease
+ * protocol does not manage (the footer composer and standalone stores).
+ */
+export type UnleasedReason = Extract<EditAuthority, {
+    kind: 'exempt';
+}>['reason'] | 'unmanaged-surface';
+/**
+ * A mount either declares an exemption, participates in the lease protocol, or is only
+ * viewing (a preview tab that has not asked to edit, so it never competes for the lease).
+ */
+export type EditorEditability = Readonly<{
+    kind: 'unleased';
+    reason: UnleasedReason;
+}> | Readonly<{
+    kind: 'viewing';
+}> | Readonly<{
+    kind: 'acquiring';
+}> | Readonly<{
+    kind: 'editable';
+    token: EditLeaseToken;
+}> | Readonly<{
+    kind: 'read-only';
+    reason: 'held-elsewhere';
+    holder: EditLeaseHolder;
+}> | Readonly<{
+    kind: 'read-only';
+    reason: 'unreachable';
+}>;
+/** The explicit editability of a store that no lease manages, such as the footer composer. */
+export declare const unmanagedSurfaceEditability: EditorEditability;
+export declare function canEditorWrite(editability: EditorEditability): boolean;
+/**
+ * Whether a mount's editing surface is made inert. A viewer is never blocked (its writes are
+ * refused by the store and the API client instead); a tab waiting for or denied the lease is.
+ */
+export declare function blocksEditingSurface(editability: EditorEditability): boolean;

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;