@riverbankcms/sdk 0.147.0 → 0.148.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/_dts/core/src/branded.d.ts

@@ -29,6 +29,8 @@ export type ApiKeyId = Brand<string, 'ApiKeyId'>;
 export type SiteRouteId = Brand<string, 'SiteRouteId'>;
 export type PageId = Brand<string, 'PageId'>;
 export type PageSurfaceId = Brand<string, 'PageSurfaceId'>;
+export type EditLeaseToken = Brand<string, 'EditLeaseToken'>;
+export type EditorClientId = Brand<string, 'EditorClientId'>;
 export type OccurrenceId = Brand<string, 'OccurrenceId'>;
 export type EventOfferingId = Brand<string, 'EventOfferingId'>;
 export type EventSeriesId = Brand<string, 'EventSeriesId'>;
@@ -116,6 +118,10 @@ export type ContentBlockId = Brand<string, 'ContentBlockId'>;
 export type ContentVersionId = Brand<string, 'ContentVersionId'>;
 export type EntryContentHash = Brand<string, 'EntryContentHash'>;
 export type StripeInvoiceId = Brand<string, 'StripeInvoiceId'>;
+/** A platform (not Connect) Stripe customer id, `cus_…`. */
+export type StripeCustomerId = Brand<string, 'StripeCustomerId'>;
+/** A Stripe subscription id, `sub_…`. */
+export type StripeSubscriptionId = Brand<string, 'StripeSubscriptionId'>;
 export type NewsletterSubscriberId = Brand<string, 'NewsletterSubscriberId'>;
 export type NavigationMenuId = Brand<string, 'NavigationMenuId'>;
 export type NavigationItemId = Brand<string, 'NavigationItemId'>;
@@ -178,6 +184,8 @@ export declare const unsafeAsApiKeyId: (id: string) => ApiKeyId;
 export declare const unsafeAsSiteRouteId: (id: string) => SiteRouteId;
 export declare const unsafeAsPageId: (id: string) => PageId;
 export declare const unsafeAsPageSurfaceId: (id: string) => PageSurfaceId;
+export declare const unsafeAsEditLeaseToken: (id: string) => EditLeaseToken;
+export declare const unsafeAsEditorClientId: (id: string) => EditorClientId;
 export declare const unsafeAsOccurrenceId: (id: string) => OccurrenceId;
 export declare const unsafeAsEventOfferingId: (id: string) => EventOfferingId;
 export declare const unsafeAsEventSeriesId: (id: string) => EventSeriesId;
@@ -250,6 +258,8 @@ export declare const unsafeAsContentBlockId: (id: string) => ContentBlockId;
 export declare const unsafeAsContentVersionId: (id: string) => ContentVersionId;
 export declare const unsafeAsEntryContentHash: (value: string) => EntryContentHash;
 export declare const unsafeAsStripeInvoiceId: (id: string) => StripeInvoiceId;
+export declare const unsafeAsStripeCustomerId: (id: string) => StripeCustomerId;
+export declare const unsafeAsStripeSubscriptionId: (id: string) => StripeSubscriptionId;
 export declare const unsafeAsNewsletterSubscriberId: (id: string) => NewsletterSubscriberId;
 export declare const unsafeAsNavigationMenuId: (id: string) => NavigationMenuId;
 export declare const unsafeAsNavigationItemId: (id: string) => NavigationItemId;
@@ -286,6 +296,8 @@ export declare const parseApiKeyId: (value: unknown) => Result<ApiKeyId, Branded
 export declare const parseSiteRouteId: (value: unknown) => Result<SiteRouteId, BrandedIdParseError>;
 export declare const parsePageId: (value: unknown) => Result<PageId, BrandedIdParseError>;
 export declare const parsePageSurfaceId: (value: unknown) => Result<PageSurfaceId, BrandedIdParseError>;
+export declare const parseEditLeaseToken: (value: unknown) => Result<EditLeaseToken, BrandedIdParseError>;
+export declare const parseEditorClientId: (value: unknown) => Result<EditorClientId, BrandedIdParseError>;
 export declare const parseOccurrenceId: (value: unknown) => Result<OccurrenceId, BrandedIdParseError>;
 export declare const parseEventOfferingId: (value: unknown) => Result<EventOfferingId, BrandedIdParseError>;
 export declare const parseEventAttendeeTicketLineId: (value: unknown) => Result<EventAttendeeTicketLineId, BrandedIdParseError>;

package/dist/_dts/core/src/currency-format.d.ts

@@ -17,9 +17,10 @@ export declare function unsafeCurrencyCode(value: string): CurrencyCode;
 /**
  * Trailing-decimal policy for a formatted amount:
  * - 'exact' : the currency's natural precision (usually 2) — "£25.00"
- * - 'auto'  : drop trailing zeros within the currency's natural precision — "£25", "£25.50"
+ * - 'auto'  : drop trailing zeros within the currency's natural precision — "£25", "£25.5"
+ * - 'whole' : round to whole major units — "£25"
  */
-export type CurrencyDecimals = 'exact' | 'auto';
+export type CurrencyDecimals = 'exact' | 'auto' | 'whole';
 export type FormatCurrencyOptions = Readonly<{
     /** Defaults to 'exact'. */
     decimals?: CurrencyDecimals;
@@ -36,4 +37,9 @@ export type FormatCurrencyOptions = Readonly<{
  * own `Intl.NumberFormat`.
  */
 export declare function formatCurrencyAmount(amountCents: number, currency: string, options?: FormatCurrencyOptions): string;
+/**
+ * `formatCurrencyAmount` for an amount already in MAJOR units (29.99 = £29.99),
+ * such as a registrar price. Prefer minor units everywhere else.
+ */
+export declare function formatCurrencyMajorUnits(amount: number, currency: string, options?: FormatCurrencyOptions): string;
 export {};

package/dist/_dts/core/src/demo-lifecycle-status.d.ts

@@ -1,10 +1,10 @@
 export declare const demoBlueprintStatusValues: readonly ["draft", "published", "archived"];
 export type DemoBlueprintStatus = (typeof demoBlueprintStatusValues)[number];
-export declare const demoInstanceStatusValues: readonly ["warming", "available", "claimed", "expired", "recycling", "failed"];
+export declare const demoInstanceStatusValues: readonly ["warming", "available", "claimed", "expired", "showcase", "failed"];
 export type DemoInstanceStatus = (typeof demoInstanceStatusValues)[number];
 export declare const demoClaimStatusValues: readonly ["active", "expired", "released"];
 export type DemoClaimStatus = (typeof demoClaimStatusValues)[number];
-export declare const demoBlueprintArtifactKindValues: readonly ["site_backup", "manual_snapshot"];
+export declare const demoBlueprintArtifactKindValues: readonly ["recipe"];
 export type DemoBlueprintArtifactKind = (typeof demoBlueprintArtifactKindValues)[number];
 export declare function narrowDemoInstanceStatus(value: string): DemoInstanceStatus;
 export declare function narrowDemoClaimStatus(value: string): DemoClaimStatus;

package/dist/_dts/core/src/demo-warm-pool-target.d.ts

@@ -0,0 +1,8 @@
+import { type Result } from './result';
+export declare const DEFAULT_DEMO_WARM_POOL_TARGET = 0;
+export declare const MAX_DEMO_WARM_POOL_TARGET = 20;
+export type DemoWarmPoolTargetError = Readonly<{
+    kind: 'invalid_demo_warm_pool_target';
+    message: 'DEMO_WARM_POOL_TARGET must be a whole number from 0 to 20.';
+}>;
+export declare function parseDemoWarmPoolTarget(value: string | null | undefined): Result<number, DemoWarmPoolTargetError>;

package/dist/_dts/core/src/edit-lease.d.ts

@@ -0,0 +1,55 @@
+import type { ContentEntryId, EditLeaseToken, EditorClientId, PageId, PageSurfaceId } from './branded';
+export type EditLeaseScope = Readonly<{
+    nodeType: 'page';
+    nodeId: PageId;
+}> | Readonly<{
+    nodeType: 'content_entry';
+    nodeId: ContentEntryId;
+}> | Readonly<{
+    nodeType: 'page_surface';
+    nodeId: PageSurfaceId;
+}>;
+export type EditLeaseHolder = Readonly<{
+    kind: 'your-other-tab';
+}> | Readonly<{
+    kind: 'another-user';
+    name: string | null;
+}>;
+export type EditLeaseView = Readonly<{
+    kind: 'free';
+}> | Readonly<{
+    kind: 'mine';
+    expiresAt: string;
+}> | Readonly<{
+    kind: 'held-elsewhere';
+    holder: EditLeaseHolder;
+    expiresAt: string;
+}>;
+export type EditLeaseAcquireResult = Readonly<{
+    kind: 'granted';
+    token: EditLeaseToken;
+    expiresAt: string;
+}> | Extract<EditLeaseView, {
+    kind: 'held-elsewhere';
+}>;
+export type EditAuthority = Readonly<{
+    kind: 'edit-lease';
+    token: EditLeaseToken;
+    clientId: EditorClientId;
+}> | Readonly<{
+    kind: 'exempt';
+    reason: 'team-member-profile' | 'sdk';
+}>;
+export type OwnerEditAuthority = EditAuthority | Readonly<{
+    kind: 'no-lease-headers';
+}>;
+export type EditLeaseTarget = Readonly<{
+    kind: 'leased';
+    scope: EditLeaseScope;
+}> | Readonly<{
+    kind: 'unleased';
+}>;
+export declare function parseEditLeaseScope(input: Readonly<{
+    nodeType: EditLeaseScope['nodeType'];
+    nodeId: string;
+}>): EditLeaseScope | null;

package/dist/_dts/core/src/editor-state.d.ts

@@ -1,5 +1,6 @@
+import type { EditorBlockVersions } from './block-content-identity';
 import type { Brand } from './branded';
-import type { BlockContentIdentity } from './block-content-identity';
+import type { ValueSync } from './editor-value-sync';
 export type EditorSiteId = Brand<string, 'EditorSiteId'>;
 export type EditorPageId = Brand<string, 'EditorPageId'>;
 export type EditorEntryId = Brand<string, 'EditorEntryId'>;
@@ -8,6 +9,31 @@ export declare const unsafeAsEditorSiteId: (value: string) => EditorSiteId;
 export declare const unsafeAsEditorPageId: (value: string) => EditorPageId;
 export declare const unsafeAsEditorEntryId: (value: string) => EditorEntryId;
 export declare const unsafeAsEditorBlockId: (value: string) => EditorBlockId;
+/** Identity of the ordered block collection currently mounted in the editor. */
+export type EditorBlockCollectionOwner = Readonly<{
+    kind: 'page';
+    pageId: string;
+}> | Readonly<{
+    kind: 'entry-slot';
+    type: string;
+    entryId: string;
+    slotKey: string;
+}> | Readonly<{
+    kind: 'surface-slot';
+    pageSurfaceId: string;
+    slotKey: string;
+}> | Readonly<{
+    kind: 'site-footer';
+    siteId: string;
+}>;
+/** Server membership facts for a loaded collection, independent of selected local edits. */
+export type EditorBlockCollectionReadBaseline = Readonly<{
+    owner: EditorBlockCollectionOwner;
+    currentBlockIds: readonly string[];
+    publishedBlockIds: readonly string[];
+}>;
+export declare function editorBlockCollectionOwnerKey(owner: EditorBlockCollectionOwner): string;
+export declare function editorBlockCollectionOwnersEqual(left: EditorBlockCollectionOwner | null, right: EditorBlockCollectionOwner | null): boolean;
 export type EditorValueRecord = Readonly<Record<string, unknown>>;
 export type EditorMetadataValues = Brand<EditorValueRecord, 'EditorMetadataValues'>;
 export type EditorContentValues = Brand<EditorValueRecord, 'EditorContentValues'>;
@@ -15,6 +41,7 @@ export type EditorBlockValues = Brand<EditorValueRecord, 'EditorBlockValues'>;
 export declare const unsafeAsEditorMetadataValues: (value: EditorValueRecord) => EditorMetadataValues;
 export declare const unsafeAsEditorContentValues: (value: EditorValueRecord) => EditorContentValues;
 export declare const unsafeAsEditorBlockValues: (value: EditorValueRecord) => EditorBlockValues;
+/** Presentation of a value's sync state, derived from its `ValueSync` (`syncStateOf`). */
 export type EditorSyncState = {
     kind: 'baseline';
 } | {
@@ -28,15 +55,12 @@ export type EditorStructuralDraftMeta = Readonly<{
     kind: string;
     purpose: string | null;
     orderIndex: number | null;
-    publishedContent: EditorBlockValues | null;
-    optimisticHash: string | null;
 }>;
+/** The baseline revision is the block's optimistic hash. */
 export type EditorStructuralDraftSnapshot = Readonly<{
     id: EditorBlockId;
     version: number;
-    baseline: EditorBlockValues | null;
-    current: EditorBlockValues | null;
-    syncState: EditorDraftSyncState;
+    sync: ValueSync<EditorBlockValues | null>;
     meta: EditorStructuralDraftMeta;
 }>;
 export type EditorBlockDataRowInput = Readonly<{
@@ -47,28 +71,29 @@ export type EditorDraftBlockInitMetaInput = Readonly<{
     kind: string;
     purpose?: string | null;
     orderIndex?: number | null;
-    publishedContent?: EditorBlockBaselineInput;
     optimisticHash?: string | null;
 }>;
 export type EditorDraftBlockBaselineUpdateMetaInput = Readonly<{
     kind?: string;
     purpose?: string | null;
     orderIndex?: number | null;
-    publishedContent?: EditorBlockBaselineInput;
     optimisticHash?: string | null;
 }>;
-export type EditorBlockPublishedBaselineInput = Readonly<{
+/** One block's server versions, as recorded into the editor's block-versions state. */
+export type EditorBlockVersionsEntry = Readonly<{
     id: EditorBlockId;
-    kind?: string;
-    publishedContent?: EditorBlockBaselineInput;
+    versions: EditorBlockVersions;
 }>;
-export type EditorPersistedBlock = BlockContentIdentity & Readonly<{
+/**
+ * A block as undo history records it. Server version identity is deliberately
+ * absent: it lives in the editor's block-versions state, outside history.
+ */
+export type EditorPersistedBlock = Readonly<{
     id: EditorBlockId;
     kind: string;
     content: EditorBlockValues | null;
     orderIndex: number | null;
     draftContent: EditorBlockValues | null;
-    publishedContent: EditorBlockValues | null;
     bindings: EditorBlockValues | null;
     purpose: string | null;
     optimisticHash: string | null;

package/dist/_dts/core/src/editor-value-sync.d.ts

@@ -0,0 +1,79 @@
+import type { Brand } from './branded';
+import type { EditorSyncState } from './editor-state';
+/**
+ * One editor value's sync state: the server baseline it was loaded from, and what the
+ * person intends locally. The request slot nests under local intent, so a pristine value
+ * can never hold a send in flight or a failure (issue 1553, D1).
+ *
+ * The transitions live in `@riverbankcms/content-editor`'s `sync/valueSync.ts`. The
+ * read-only selectors below live here because block-form and editor-blocks read them
+ * and can't depend on content-editor.
+ */
+/** Identifies one save request; a response for any other id is ignored. Allocated by the store. */
+export type SendId = Brand<number, 'SendId'>;
+export declare const unsafeAsSendId: (value: number) => SendId;
+/** The server's compare-and-set token for a baseline. Compared by equality only. */
+export type BaselineRevision = Readonly<{
+    kind: 'known';
+    value: string | null;
+}> | Readonly<{
+    kind: 'unknown';
+}>;
+export type ValueBaseline<V> = Readonly<{
+    values: V;
+    revision: BaselineRevision;
+}>;
+export type IdleRequest = Readonly<{
+    kind: 'idle';
+}>;
+export type InFlightRequest<V> = Readonly<{
+    kind: 'in-flight';
+    id: SendId;
+    sent: V;
+    basis: BaselineRevision;
+}>;
+export type FailedRequest<V> = Readonly<{
+    kind: 'failed';
+    id: SendId;
+    sent: V;
+    error: string;
+    reason: 'rejected' | 'conflict';
+}>;
+/** A request still outstanding whose edits the person discarded. It presents as saved. */
+export type AbandonedRequest = Readonly<{
+    kind: 'abandoned';
+    id: SendId;
+    basis: BaselineRevision;
+}>;
+export type PristineRequest = IdleRequest | AbandonedRequest;
+export type EditedRequest<V> = IdleRequest | InFlightRequest<V> | FailedRequest<V> | AbandonedRequest;
+export type LocalIntent<V> = Readonly<{
+    kind: 'pristine';
+    request: PristineRequest;
+}> | Readonly<{
+    kind: 'edited';
+    values: V;
+    request: EditedRequest<V>;
+}>;
+export type ValueSync<V> = Readonly<{
+    baseline: ValueBaseline<V>;
+    local: LocalIntent<V>;
+}>;
+/** Lease loss isn't an error: the edits stay unsaved and send again once the tab can write. */
+export type SaveFailure = Readonly<{
+    kind: 'rejected' | 'conflict';
+    message: string;
+}> | Readonly<{
+    kind: 'lease-lost';
+}>;
+export declare const UNKNOWN_REVISION: BaselineRevision;
+export declare function knownRevision(value: string | null): BaselineRevision;
+/** A pristine value at the given baseline. */
+export declare function pristineValueSync<V>(values: V, revision: BaselineRevision): ValueSync<V>;
+export type ValueStatus = 'saved' | 'unsaved' | 'saving' | 'failed';
+/** What the person sees: their edits, or the baseline when there are none. */
+export declare function displayedValues<V>(sync: ValueSync<V>): V;
+/** Pristine counts as saved even with an abandoned request: nothing the person wants is unsaved. */
+export declare function valueStatus<V>(sync: ValueSync<V>): ValueStatus;
+/** Projects the model onto the presentation sync state: unsaved and saving are both `pending`. */
+export declare function syncStateOf<V>(sync: ValueSync<V>): EditorSyncState;

package/dist/_dts/core/src/html-entities.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Decodes the HTML entities rendered pages commonly contain (the basic named
+ * set plus decimal and hex numeric references), leaving anything else as is.
+ * For reading text back out of server-rendered HTML, not for sanitising input.
+ */
+export declare function decodeHtmlEntities(text: string): string;

package/dist/_dts/core/src/index.d.ts

@@ -1,9 +1,11 @@
 export * from './branded';
 export * from './date-math';
+export * from './html-entities';
 export * from './duration';
 export * from './demo-capability-policy';
 export * from './demo-claim-access';
 export * from './demo-lifecycle-status';
+export * from './demo-warm-pool-target';
 export * from './demo-runtime';
 export * from './collections';
 export * from './event-booking-offer';
@@ -30,6 +32,8 @@ export { tryAsync } from './try-async';
 export * from './narrow-result';
 export * from './non-empty-array';
 export * from './editor-state';
+export * from './editor-value-sync';
+export * from './edit-lease';
 export * from './block-content-identity';
 export * from './sensitive-collection';
 export * from './assertNever';

package/dist/_dts/core/src/uuid.d.ts

@@ -1,6 +1,8 @@
-/**
- * Validates whether a string matches UUID v4 format
- * Format: 8-4-4-4-12 hexadecimal digits
- * Example: 550e8400-e29b-41d4-a716-446655440000
- */
+/** Validate a UUID in the existing 8-4-4-4-12 hexadecimal format. */
 export declare function isValidUuid(str: string): boolean;
+/** UUID v4 generation in both secure and local HTTP browser contexts. */
+export type UuidCryptoSource = Readonly<{
+    randomUUID?: () => string;
+    getRandomValues: (array: Uint8Array<ArrayBuffer>) => Uint8Array<ArrayBuffer>;
+}>;
+export declare function generateUuidV4(cryptoSource?: UuidCryptoSource): string;