@riverbankcms/sdk 0.80.0 → 0.81.0

package/dist/_dts/blocks/src/system/runtime/nodes/media.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { type ResolvedMediaTransform, type DirectImageUrlOptions } from '../../../../../media-core/src/index';
+import { type ResolvedMediaTransform, type DirectImageUrlOptions, type RenderableMediaAsset, type RenderableMediaAssetIndex } from '../../../../../media-core/src/index';
 import type { Media } from '../../../lib/media';
 /**
  * Options for image URL resolution.
@@ -33,19 +33,8 @@ export type ResolveImageUrlContextInput = Readonly<{
     mediaAssetIndex?: MediaAssetIndex;
     mediaAssets?: readonly MediaAssetIndexItem[];
 }>;
-export type MediaAssetIndexItem = Readonly<{
-    id: string;
-    identifier?: string | null;
-    storageBucket?: string;
-    storagePath?: string;
-    width?: number | null;
-    height?: number | null;
-    mimeType?: string;
-}>;
-export type MediaAssetIndex = Readonly<{
-    byId: ReadonlyMap<string, MediaAssetIndexItem>;
-    byIdentifier: ReadonlyMap<string, MediaAssetIndexItem>;
-}>;
+export type MediaAssetIndexItem = RenderableMediaAsset;
+export type MediaAssetIndex = RenderableMediaAssetIndex;
 export declare function buildMediaAssetIndex(assets: readonly MediaAssetIndexItem[] | undefined): MediaAssetIndex | undefined;
 export type ResolveImageSourceSetOptions = {
     widthCandidates?: readonly number[];
@@ -65,8 +54,30 @@ export type ResolvedImageSourceSet = {
      */
     fallbackSrc?: string;
 };
+export type MediaUrlResolution = Readonly<{
+    kind: 'resolved';
+    url: string;
+}> | Readonly<{
+    kind: 'unsupported-media-type';
+    mediaType: string | undefined;
+}> | Readonly<{
+    kind: 'missing-storage-path';
+    assetId?: string;
+    identifier?: string | null;
+}> | Readonly<{
+    kind: 'missing-site-context';
+    storagePath: string;
+}> | Readonly<{
+    kind: 'missing-supabase-url';
+    message: string;
+}> | Readonly<{
+    kind: 'missing-image-url';
+    assetId?: string;
+    identifier?: string | null;
+}>;
 export declare function buildResolveImageUrlContext(input: ResolveImageUrlContextInput | undefined): ResolveImageUrlContext;
 export declare function resolveMediaStorageUrl(value: Media, context?: ResolveImageUrlContext | null, transformOptions?: DirectImageUrlOptions): string | undefined;
+export declare function resolveMediaStorageUrlResult(value: Media, context?: ResolveImageUrlContext | null, transformOptions?: DirectImageUrlOptions): MediaUrlResolution;
 /**
  * Common image size presets.
  * Use these for consistent sizing across the application.
@@ -176,6 +187,8 @@ export type MediaNodeProps = {
     /** Optional block metadata injected by the runtime resolver */
     blockKind?: string | null;
     blockContent?: unknown;
+    /** Render-scoped media sidecar/context injected by PageRenderer. */
+    imageResolveContext?: ResolveImageUrlContext | null;
 };
 export type VideoPlaybackMode = 'inline' | 'background';
 export declare function resolveMediaNodeResponsiveImage(value: Media, size: ImageOptions, style: React.CSSProperties | undefined, slot: {
@@ -227,6 +240,8 @@ export declare const MediaNode: React.FC<MediaNodeProps>;
  * ```
  */
 export declare function resolveImageUrl(value: Media, options: ImageOptions, context?: ResolveImageUrlContext | null): string | undefined;
+export declare function resolveImageUrlResult(value: Media, options: ImageOptions, context?: ResolveImageUrlContext | null): MediaUrlResolution;
 export declare function resolveImageUrlWithContext(value: Media, options: ImageOptions, context?: ResolveImageUrlContext | null, transformAspectRatio?: number | string): string | undefined;
+export declare function resolveImageUrlWithContextResult(value: Media, options: ImageOptions, context?: ResolveImageUrlContext | null, transformAspectRatio?: number | string): MediaUrlResolution;
 export declare function resolveImageSourceSetWithContext(value: Media, options: ResolveImageSourceSetOptions, context?: ResolveImageUrlContext | null): ResolvedImageSourceSet | undefined;
 export {};

package/dist/_dts/blocks/src/system/runtime/nodes/offerings-preview.d.ts

@@ -0,0 +1,21 @@
+import type { PublicCourse } from "../../blocks/courses/shared/types";
+import type { ButtonVariant, PublicEvent } from "../../blocks/events/shared/types";
+import type { CardStylesContent } from "../../fields/boxStyles";
+import { type BookingOfferingPresetSummary, type OfferingsPreviewEventDataKey, type OfferingsPreviewGroupOverride, type OfferingsPreviewRouteCandidate } from "../../blocks/offerings-preview/model";
+type OfferingsPreviewProps = Readonly<{
+    bookingOfferingPresets?: readonly BookingOfferingPresetSummary[] | null;
+    groupOverrides?: readonly OfferingsPreviewGroupOverride[] | null;
+    cardStyles?: CardStylesContent;
+    itemLimit?: string | null;
+    buttonVariant?: ButtonVariant | null;
+    buttonText?: string | null;
+    emptyMessage?: string | null;
+    failedMessage?: string | null;
+    previewStage?: "published" | "preview" | null;
+    routeCandidates?: Readonly<{
+        routes?: readonly OfferingsPreviewRouteCandidate[] | null;
+    }> | null;
+    courses?: readonly PublicCourse[] | null;
+}> & Partial<Record<OfferingsPreviewEventDataKey, readonly PublicEvent[] | null>>;
+export declare function OfferingsPreviewNode(props: OfferingsPreviewProps): import("react/jsx-runtime").JSX.Element | null;
+export default OfferingsPreviewNode;

package/dist/_dts/blocks/src/system/runtime/resolver.d.ts

@@ -3,8 +3,13 @@ import type { NodeDefinition } from "../node";
 import { bindingSchema } from "../node";
 import { type ThemeTokens } from "../theme";
 import type { TransformRegistry, RouteMap, PageIdentifierMap, EntryIdentifierMap } from "../transforms";
+import type { ResolveImageUrlContext } from "./nodes/media";
 export type ViewModel = Record<string, unknown>;
 export type ComponentRegistry = Record<string, React.ElementType>;
+export type PreviewTextFieldConstraints = Readonly<{
+    maxLength?: number;
+}>;
+export type PreviewFieldConstraintsMap = Readonly<Record<string, PreviewTextFieldConstraints | undefined>>;
 export type ResolverContext = {
     viewModel: ViewModel;
     registry: ComponentRegistry;
@@ -22,6 +27,8 @@ export type ResolverContext = {
     blockBindings?: Record<string, unknown>;
     editableRouteMetadataFieldIds?: ReadonlyArray<string>;
     fragmentRegistry?: Record<string, unknown>;
+    fieldConstraints?: PreviewFieldConstraintsMap;
+    imageResolveContext?: ResolveImageUrlContext;
 };
 /** @internal Exported for testing */
 export type ScopeEntry = {

package/dist/_dts/blocks/src/system/transforms/registry/_utils/sectionForegroundStyles.d.ts

@@ -0,0 +1,2 @@
+import type { TransformContext } from "../core";
+export declare function resolveSectionForegroundStyles(value: unknown, context: TransformContext): Record<string, string>;

package/dist/_dts/blocks/src/system/transforms/registry/boxStyles.d.ts

@@ -147,14 +147,16 @@ type SectionHeadingColorOptions = {
  */
 export declare const sectionHeadingColorStyleTransform: TransformDefinition<SectionHeadingColorOptions>;
 /**
- * Resolves section text and heading colors from the background object.
+ * Resolves section foreground colors from the background object.
  *
  * The value should be the full `_sectionStyles.background` object.
  * Outputs:
  * - `color` and `--section-text-color` from background.textColor
  * - `--section-heading-color` from background.headingColor (falls back to textColor if not set)
+ * - `--section-link-color` from background.linkColor (falls back to textColor if not set)
+ * - `--section-supporting-color` from background.supportingColor (falls back to textColor if not set)
  *
- * This combined transform replaces separate textColor/headingColor transforms
+ * This combined transform replaces separate foreground color transforms
  * when both need to be applied to the same style prop.
  */
 export declare const sectionColorsStyleTransform: TransformDefinition<Record<string, never>>;

package/dist/_dts/calendar/src/grid.d.ts

@@ -6,6 +6,21 @@
  * cells with `groupItemsByDate` from `./group`.
  */
 export type WeekStart = 'sunday' | 'monday';
+export type CalendarViewportKind = 'month' | 'week';
+export type WeekCalendarDays = readonly [Date, Date, Date, Date, Date, Date, Date];
+export type MonthCalendarViewport = Readonly<{
+    kind: 'month';
+    anchorDate: Date;
+    days: readonly Date[];
+    title: string;
+}>;
+export type WeekCalendarViewport = Readonly<{
+    kind: 'week';
+    anchorDate: Date;
+    days: WeekCalendarDays;
+    title: string;
+}>;
+export type CalendarViewport = MonthCalendarViewport | WeekCalendarViewport;
 export declare const DAY_NAMES: readonly ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 export declare const MONTH_NAMES: readonly ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
 /**
@@ -31,6 +46,10 @@ export declare function getEndOfMonth(date: Date): Date;
  * in non-leap years).
  */
 export declare function addMonths(date: Date, months: number): Date;
+/** Add (or subtract) days while preserving local time-of-day fields. */
+export declare function addDays(date: Date, days: number): Date;
+/** Shift a calendar anchor by the natural unit for a viewport kind. */
+export declare function shiftCalendarAnchorDate(date: Date, view: CalendarViewportKind, steps: number): Date;
 /**
  * Get an inclusive 3-month window around `date`, returned as ISO strings
  * with UTC midnight bounds. Suitable for prefetching event windows when
@@ -47,6 +66,8 @@ export declare function getThreeMonthRange(date: Date): {
 export declare function getMonthCalendarDays(year: number, month: number, startOfWeek: WeekStart): Date[];
 /** Build the 7 dates of the week containing `baseDate`. */
 export declare function getWeekCalendarDays(baseDate: Date, startOfWeek: WeekStart): Date[];
+/** Build the 7 dates of the week containing `baseDate` as a fixed-width tuple. */
+export declare function getWeekCalendarDayTuple(baseDate: Date, startOfWeek: WeekStart): WeekCalendarDays;
 /**
  * Day-name labels reordered for the chosen week start. Pass a custom
  * `dayNames` array (length 7, Sunday-first) to localize.
@@ -58,3 +79,9 @@ export declare function getOrderedDayNames(startOfWeek: WeekStart, dayNames?: re
  *   - week:  "January 5 - 11, 2025" or "December 30 - January 5, 2025"
  */
 export declare function formatCalendarTitle(viewDate: Date, view: 'month' | 'week', days: Date[], monthNames?: readonly string[]): string;
+export declare function buildCalendarViewport(input: Readonly<{
+    view: CalendarViewportKind;
+    anchorDate: Date;
+    startOfWeek: WeekStart;
+    monthNames?: readonly string[];
+}>): CalendarViewport;

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

@@ -1,5 +1,5 @@
-export type { WeekStart } from './grid';
-export { getMonthCalendarDays, getWeekCalendarDays, getOrderedDayNames, formatCalendarTitle, formatDateKey, isToday, isSameLocalDay, addMonths, getStartOfMonth, getEndOfMonth, getThreeMonthRange, DAY_NAMES, MONTH_NAMES, MAX_EVENTS_PER_DAY, } from './grid';
+export type { CalendarViewport, CalendarViewportKind, MonthCalendarViewport, WeekCalendarDays, WeekCalendarViewport, WeekStart, } from './grid';
+export { addDays, buildCalendarViewport, getMonthCalendarDays, getWeekCalendarDays, getWeekCalendarDayTuple, getOrderedDayNames, formatCalendarTitle, formatDateKey, isToday, isSameLocalDay, addMonths, shiftCalendarAnchorDate, getStartOfMonth, getEndOfMonth, getThreeMonthRange, DAY_NAMES, MONTH_NAMES, MAX_EVENTS_PER_DAY, } from './grid';
 export type { TimetableInput, TimetableModel, TimetableDay, TimetableCell, TimetableBounds, TimetableDiagnostic, InvalidItemReason, TimetableView, } from './timetable';
 export { buildTimetableModel } from './timetable';
 export type { GroupItemsByDateAccessors } from './group';

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

@@ -1,10 +1,12 @@
 import type { useStoreAutosave } from '../hooks/useStoreAutosave';
 import type { useBlockAutosave } from '../hooks/useBlockAutosave';
+import type { AutosaveHandle } from '../hooks/useSimpleAutosave';
 import type { createEditorUiStore } from '../ui/editorUiStore';
 type UseAutosaveTriggersProps = {
     uiStore: ReturnType<typeof createEditorUiStore>;
     metadataAutosave: ReturnType<typeof useStoreAutosave>;
     blockAutosave: ReturnType<typeof useBlockAutosave>;
+    linkedEntryAutosave?: AutosaveHandle | null;
     /** Content autosave - only provided for content entries (not pages) */
     contentAutosave?: ReturnType<typeof useStoreAutosave> | null;
     hasRoute: boolean;
@@ -23,5 +25,5 @@ type UseAutosaveTriggersProps = {
  * transition tracking. When a user continues editing during/after save,
  * status stays 'pending' but version increments, so we still trigger.
  */
-export declare function useAutosaveTriggers({ uiStore, metadataAutosave, blockAutosave, contentAutosave, hasRoute, enableTriggers, }: UseAutosaveTriggersProps): void;
+export declare function useAutosaveTriggers({ uiStore, metadataAutosave, blockAutosave, linkedEntryAutosave, contentAutosave, hasRoute, enableTriggers, }: UseAutosaveTriggersProps): void;
 export {};

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

@@ -0,0 +1 @@
+export * from './ui/editorTransactionState';

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

@@ -0,0 +1,26 @@
+import type { EditorSyncState } from '../../../core/src/index';
+import type { LinkedContentEntryId } from '../linkedEntries/domain';
+import type { AutosaveStatus } from '../ui/stores/types';
+export { unsafeAsLinkedContentEntryId, type LinkedContentEntryId, } from '../linkedEntries/domain';
+export type EditorAutosaveScope = Readonly<{
+    kind: 'metadata';
+}> | Readonly<{
+    kind: 'content';
+}> | Readonly<{
+    kind: 'blocks';
+}> | Readonly<{
+    kind: 'linkedEntry';
+    entryId: LinkedContentEntryId;
+}>;
+export type EditorAutosaveSchedulerKey = 'metadata' | 'content' | 'blocks' | 'linkedEntries';
+export type AutosaveScopeSnapshot = Readonly<{
+    scope: EditorAutosaveScope;
+    syncState: EditorSyncState;
+}>;
+export type AutosaveStatusByScheduler = Readonly<Record<EditorAutosaveSchedulerKey, AutosaveStatus>>;
+export declare function autosaveScopeKey(scope: EditorAutosaveScope): string;
+export declare function autosaveSchedulerKey(scope: EditorAutosaveScope): EditorAutosaveSchedulerKey;
+export declare function uniqueAutosaveSchedulerKeys(scopes: readonly EditorAutosaveScope[]): EditorAutosaveSchedulerKey[];
+export declare function deriveDirtyAutosaveScopes(snapshots: readonly AutosaveScopeSnapshot[]): EditorAutosaveScope[];
+export declare function hasAutosaveStatusFailure(statuses: AutosaveStatusByScheduler): boolean;
+export declare function allAutosaveStatusesComplete(statuses: AutosaveStatusByScheduler): boolean;

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

@@ -31,6 +31,7 @@ export type PublishabilityAutosaveState = Readonly<{
     metadata: AutosaveStatus;
     content: AutosaveStatus;
     blocks: AutosaveStatus;
+    linkedEntries: AutosaveStatus;
 }>;
 export type DerivePublishabilityInput = Readonly<{
     unpublishedState: EditorUnpublishedState;

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

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

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

@@ -1,4 +1,4 @@
-import type { EditorStatusBarToolbar } from "@riverbankcms/editor";
+import type { EditorStatusBarToolbar } from "../../../editor/src/index";
 /**
  * Builds a reactive toolbar for the editor status bar.
  *

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

@@ -23,8 +23,8 @@ type AutosaveConfig<TValues, TPayload> = {
     enabled?: boolean;
     /** UI store instance for updating autosave status */
     uiStore: EditorUiStoreInstance;
-    /** Which autosave type: 'metadata', 'blocks', or 'content' */
-    type: 'metadata' | 'blocks' | 'content';
+    /** Which autosave scheduler this hook updates */
+    type: 'metadata' | 'blocks' | 'content' | 'linkedEntries';
 };
 export type AutosaveHandle = {
     trigger: () => void;

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

@@ -4,6 +4,8 @@ export { useDebouncedLatestSave, type DebouncedLatestSaveConfig, type DebouncedL
 export { useSimpleAutosave, useMultiAutosave } from './hooks/useSimpleAutosave';
 export { useStoreAutosave, type StoreAutosaveConfig, type AutosaveScope } from './hooks/useStoreAutosave';
 export { useBlockAutosave, type BlockAutosaveOptions } from './hooks/useBlockAutosave';
+export { collectPendingLinkedEntrySaves, useLinkedEntryAutosave, type LinkedEntryAutosaveOptions, type LinkedEntrySaveResult, type PendingLinkedEntrySave, } from './hooks/useLinkedEntryAutosave';
+export { unsafeAsLinkedContentEntryId, unsafeAsLinkedContentTypeKey, type LinkedContentEntryId, type LinkedContentTypeKey, } from './linkedEntries/domain';
 export { useEntryActions, type EntryActionsOptions } from './hooks/useEntryActions';
 export { useReactiveToolbar } from './hooks/useReactiveToolbar';
 export { isInvalidSaveability, selectHasInvalidBlocks } from './hooks/invalidBlockSelectors';
@@ -16,7 +18,7 @@ export { EditableBlockProvider, useBlockData } from './components/EditableBlockP
 export { ContentFieldsForm, type ContentFieldsFormProps } from './components/ContentFieldsForm';
 export { useUISelector } from './ui/useUISelector';
 export { EditorUiStoreProvider, useEditorUiStore, useEditorUiStoreInstance, useOptionalEditorUiStoreInstance, createEditorUiStore } from './ui/editorUiStore';
-export type { ActivePreviewField, EditorUiStoreInstance, EditorUiState, PreviewSidebarTab, ViewportMode, ViewportWidth, ViewportState, ZoomLevel, } from './ui/editorUiStore';
+export type { ActivePreviewField, EditorUiStoreInstance, EditorUiState, EditorPreviewInspectorStore, EditorLinkedEntrySnapshot, PreviewInspection, PreviewSidebarTab, ViewportMode, ViewportWidth, ViewportState, ZoomLevel, } from './ui/editorUiStore';
 export { PreviewTextEditor } from './primitives/PreviewTextEditor';
 export { PreviewRichTextEditor } from './primitives/PreviewRichTextEditor';
 export { useStoreBinding, parseEditorPath } from './primitives/shared';

package/dist/_dts/content-editor/src/lib/json.d.ts

@@ -0,0 +1,2 @@
+import type { JsonValue } from '../../../api/src/content-editor';
+export declare function toJsonObject(value: Record<string, unknown>): Record<string, JsonValue>;

package/dist/_dts/content-editor/src/linkedEntries/domain.d.ts

@@ -0,0 +1,8 @@
+export type LinkedContentEntryId = string & {
+    readonly __linkedContentEntryId: unique symbol;
+};
+export type LinkedContentTypeKey = string & {
+    readonly __linkedContentTypeKey: unique symbol;
+};
+export declare function unsafeAsLinkedContentEntryId(value: string): LinkedContentEntryId;
+export declare function unsafeAsLinkedContentTypeKey(value: string): LinkedContentTypeKey;

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

@@ -1,4 +1,5 @@
 import { unsafeAsEditorBlockId, unsafeAsEditorBlockValues, unsafeAsEditorContentValues, unsafeAsEditorEntryId, unsafeAsEditorMetadataValues, unsafeAsEditorPageId, unsafeAsEditorSiteId, type EditorBlockBaselineInput, type EditorBlockId, type EditorBlockPublishedBaselineInput, type EditorDraftBlockBaselineUpdateMetaInput, type EditorDraftBlockInitMetaInput, type EditorBlockValues, type EditorContentValues, type EditorEntryId, type EditorMetadataValues, type EditorPageId, type EditorPersistedBlock, type EditorSiteId, type EditorStructuralCommand, type EditorStructuralDraftSnapshot, type EditorSyncState, type EditorValueRecord } from '../../../core/src/index';
+import { type LinkedContentEntryId, type LinkedContentTypeKey } from '../linkedEntries/domain';
 export { unsafeAsEditorBlockId, unsafeAsEditorBlockValues, unsafeAsEditorContentValues, unsafeAsEditorEntryId, unsafeAsEditorMetadataValues, unsafeAsEditorPageId, unsafeAsEditorSiteId, type EditorBlockId, type EditorBlockValues, type EditorContentValues, type EditorEntryId, type EditorMetadataValues, type EditorPageId, type EditorSiteId, };
 export type EditorCommand = {
     type: 'set-metadata-value';
@@ -23,6 +24,15 @@ export type EditorCommand = {
     type: 'replace-block';
     blockId: EditorBlockId;
     value: EditorBlockValues | null;
+} | {
+    type: 'set-linked-entry-value';
+    entryId: string;
+    path: string;
+    value: unknown;
+} | {
+    type: 'replace-linked-entry';
+    entryId: string;
+    value: EditorContentValues | null;
 } | EditorStructuralCommand | {
     type: 'batch';
     changes: readonly EditorCommand[];
@@ -51,6 +61,18 @@ export type EditorValueSnapshot<TValue extends EditorValueRecord | null> = Reado
 }>;
 type EditorMetadataSnapshot = EditorValueSnapshot<EditorMetadataValues | null>;
 type EditorContentSnapshot = EditorValueSnapshot<EditorContentValues | null>;
+export type EditorLinkedEntryMeta = Readonly<{
+    entryId: LinkedContentEntryId;
+    contentTypeKey: LinkedContentTypeKey;
+    contentTypeLabel: string;
+    title: string;
+    titleField: string | null;
+    optimisticHash: string | null;
+    fields: readonly EditorValueRecord[];
+}>;
+export type EditorLinkedEntrySnapshot = EditorValueSnapshot<EditorContentValues | null> & Readonly<{
+    meta: EditorLinkedEntryMeta;
+}>;
 export type EditorBlockMeta = Readonly<{
     kind: string;
     purpose: string | null;
@@ -96,6 +118,7 @@ export type EditorHistorySnapshot = Readonly<{
      */
     blockList: readonly NormalizedEditorBlockItem[];
     drafts: Readonly<Record<EditorBlockId, EditorDraftSnapshot>>;
+    linkedEntries: Readonly<Record<string, EditorLinkedEntrySnapshot>>;
 }>;
 export declare function requirePersistedEditorBlock(block: EditorBlockItem | NormalizedEditorBlockItem): PersistedEditorBlockItem;
 export declare function createEditorDraftSnapshotFromBlock(block: PersistedEditorBlockItem): EditorDraftSnapshot;
@@ -179,6 +202,33 @@ export type EditorSystemOperation = {
 } | {
     type: 'clear-draft-pending';
     blockId: EditorBlockId;
+} | {
+    type: 'hydrate-linked-entry';
+    entryId: string;
+    contentTypeKey: string;
+    contentTypeLabel: string;
+    title: string;
+    titleField?: string | null;
+    optimisticHash?: string | null;
+    fields: readonly EditorValueRecord[];
+    baseline: EditorContentValues | null;
+    current?: EditorContentValues | null;
+} | {
+    type: 'discard-linked-entry';
+    entryId: string;
+} | {
+    type: 'save-linked-entry-succeeded';
+    entryId: string;
+    savedValues: EditorContentValues | null;
+    acknowledgedVersion: number;
+    optimisticHash?: string | null;
+} | {
+    type: 'save-linked-entry-failed';
+    entryId: string;
+    message?: string;
+} | {
+    type: 'clear-linked-entry-error';
+    entryId: string;
 } | {
     type: 'replace-block-list';
     next: readonly EditorBlockItem[];
@@ -210,7 +260,15 @@ export declare function autosaveDraftFailed(snapshot: EditorHistorySnapshot, blo
 export declare function clearDraftError(snapshot: EditorHistorySnapshot, blockId: EditorBlockId): EditorHistorySnapshot;
 export declare function setDraftPending(snapshot: EditorHistorySnapshot, blockId: EditorBlockId): EditorHistorySnapshot;
 export declare function clearDraftPending(snapshot: EditorHistorySnapshot, blockId: EditorBlockId): EditorHistorySnapshot;
+export declare function hydrateLinkedEntrySnapshot(snapshot: EditorHistorySnapshot, input: Extract<EditorSystemOperation, {
+    type: 'hydrate-linked-entry';
+}>): EditorHistorySnapshot;
+export declare function discardLinkedEntrySnapshot(snapshot: EditorHistorySnapshot, entryId: string): EditorHistorySnapshot;
+export declare function saveLinkedEntrySucceeded(snapshot: EditorHistorySnapshot, entryId: string, savedValues: EditorContentValues | null, acknowledgedVersion: number, optimisticHash?: string | null): EditorHistorySnapshot;
+export declare function saveLinkedEntryFailed(snapshot: EditorHistorySnapshot, entryId: string, message?: string): EditorHistorySnapshot;
+export declare function clearLinkedEntryError(snapshot: EditorHistorySnapshot, entryId: string): EditorHistorySnapshot;
 export declare function replaceEditorBlockList(snapshot: EditorHistorySnapshot, blockList: readonly EditorBlockItem[]): EditorHistorySnapshot;
 export declare function getDraftSnapshot(snapshot: EditorHistorySnapshot, blockId: string): EditorDraftSnapshot | null;
 export declare function inspectDrafts(snapshot: EditorHistorySnapshot): EditorDraftSnapshot[];
+export declare function getLinkedEntrySnapshot(snapshot: EditorHistorySnapshot, entryId: string): EditorLinkedEntrySnapshot | null;
 export declare function hasUnpublishedDraftChanges(snapshot: EditorHistorySnapshot): boolean;

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

@@ -0,0 +1,93 @@
+export type EditorTransaction<TAction, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    targetKey: TTargetKey;
+    action: TAction;
+    historyEntry: THistoryEntry | null;
+}>;
+export type EditorCommitPolicy = Readonly<{
+    kind: 'autosave-latest';
+}> | Readonly<{
+    kind: 'staged';
+}> | Readonly<{
+    kind: 'manual-flush';
+}>;
+export type EditorSaveBatch<TAction, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}>;
+export type EditorTransactionFailure = Readonly<{
+    kind: 'retryable';
+    message: string;
+} | {
+    kind: 'stale';
+    message: string;
+}>;
+export type EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'dirty';
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}> | Readonly<{
+    kind: 'saving';
+    batch: EditorSaveBatch<TAction, THistoryEntry, TTargetKey>;
+    followUpTransactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}> | Readonly<{
+    kind: 'failed';
+    message: string;
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}> | Readonly<{
+    kind: 'stale';
+    message: string;
+    transactions: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];
+}>;
+export type EditorTransactionCapabilities = Readonly<{
+    canApplyTransaction: boolean;
+    canStartAutosave: boolean;
+    canUseHistory: boolean;
+    requiresReload: boolean;
+}>;
+export type EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    commitPolicy: Extract<EditorCommitPolicy, {
+        kind: 'staged';
+    }>;
+    targetKey: TTargetKey;
+    base: TSnapshot;
+    preview: TSnapshot;
+    historyEntry: THistoryEntry | null;
+}>;
+export type EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey extends string = string> = Readonly<{
+    kind: 'idle';
+}> | Readonly<{
+    kind: 'active';
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}> | Readonly<{
+    kind: 'applying';
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}> | Readonly<{
+    kind: 'failed';
+    message: string;
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}> | Readonly<{
+    kind: 'stale';
+    message: string;
+    transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>;
+}>;
+export type EditorStagedSessionCapabilities = Readonly<{
+    canPreviewStaged: boolean;
+    canApplyStaged: boolean;
+    canCancelStaged: boolean;
+    isApplyingStaged: boolean;
+    requiresReload: boolean;
+}>;
+export declare function idleEditorTransactionQueueState<TAction, THistoryEntry, TTargetKey extends string = string>(): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
+export declare function idleEditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey extends string = string>(): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function deriveTransactionCapabilities(state: EditorTransactionQueueState<unknown, unknown>): EditorTransactionCapabilities;
+export declare function deriveStagedSessionCapabilities(state: EditorStagedSessionState<unknown, unknown>): EditorStagedSessionCapabilities;
+export declare function beginStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>, transaction: EditorStagedTransaction<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function applyStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function confirmStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function rejectStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>, failure: EditorTransactionFailure): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function cancelStagedSession<TSnapshot, THistoryEntry, TTargetKey extends string = string>(state: EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>): EditorStagedSessionState<TSnapshot, THistoryEntry, TTargetKey>;
+export declare function enqueueTransaction<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>, transaction: EditorTransaction<TAction, THistoryEntry, TTargetKey>): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
+export declare function beginAutosaveBatch<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
+export declare function confirmAutosaveBatch<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
+export declare function rejectAutosaveBatch<TAction, THistoryEntry, TTargetKey extends string = string>(state: EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>, failure: EditorTransactionFailure): EditorTransactionQueueState<TAction, THistoryEntry, TTargetKey>;
+export declare function coalesceQueuedTransactions<TAction, THistoryEntry, TTargetKey extends string = string>(queue: readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[], transaction: EditorTransaction<TAction, THistoryEntry, TTargetKey>): readonly EditorTransaction<TAction, THistoryEntry, TTargetKey>[];

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

@@ -3,15 +3,16 @@ import { type AutosaveState } from "./stores/autosaveStore";
 import { type ArrayKeysState } from "./stores/arrayKeysStore";
 import { type ViewportState } from "./stores/viewportStore";
 import { type AiOverlaysState } from "./stores/aiOverlaysSlice";
-import { type EditorValueSnapshot, type EditorBlockItem, type EditorBlockId, type NormalizedEditorBlockItem, type DraftBlockBaselineInput, type DraftBlockBaselineUpdateMetaInput, type DraftBlockInitMetaInput, type EditorCommand, type EditorContentValues, type EditorDraftSnapshot, type EditorEffect, type EditorHistorySnapshot, type EditorMetadataValues, type BlockPublishedBaselineInput } from "./editorHistory";
+import { type EditorValueSnapshot, type EditorBlockItem, type EditorBlockId, type NormalizedEditorBlockItem, type DraftBlockBaselineInput, type DraftBlockBaselineUpdateMetaInput, type DraftBlockInitMetaInput, type EditorCommand, type EditorContentValues, type EditorDraftSnapshot, type EditorEffect, type EditorHistorySnapshot, type EditorLinkedEntrySnapshot, type EditorMetadataValues, type BlockPublishedBaselineInput } from "./editorHistory";
 import { type HistoryState } from "./editorHistory";
 import type { FocusRequest } from "./stores/types";
+import { type LinkedContentEntryId } from "../linkedEntries/domain";
 import { type BlockDraftSaveability, type BlockDraftValidationIssue, type ResolveBlockManifest } from "./blockValidationView";
-export type { AutosaveStatusValue, AutosaveStatus, AutosaveHandle, AutosaveType, FocusRequest, ViewportMode, ViewportWidth, ZoomLevel, } from "./stores/types";
+export type { AutosaveStatusValue, AutosaveStatus, AutosaveHandle, AutosaveType, AutosaveType as AutosaveSchedulerKey, FocusRequest, ViewportMode, ViewportWidth, ZoomLevel, } from "./stores/types";
 export type { AutosaveState } from "./stores/autosaveStore";
 export type { ArrayKeysState } from "./stores/arrayKeysStore";
 export type { ViewportState } from "./stores/viewportStore";
-export type { EditorCommand, EditorBlockItem, EditorDraftSnapshot, EditorHistorySnapshot, EditorEffect, } from "./editorHistory";
+export type { EditorCommand, EditorBlockItem, EditorDraftSnapshot, EditorHistorySnapshot, EditorEffect, EditorLinkedEntrySnapshot, } from "./editorHistory";
 export type MetadataSnapshot = EditorValueSnapshot<EditorMetadataValues | null>;
 export type ContentSnapshot = EditorValueSnapshot<EditorContentValues | null>;
 export type PreviewSidebarTab = "editor" | "assistant";
@@ -48,6 +49,57 @@ export type MetadataState = {
 export type ContentState = Omit<MetadataState, "getSnapshot"> & {
     getSnapshot: () => ContentSnapshot;
 };
+export type PreviewInspection = Readonly<{
+    kind: "none";
+}> | Readonly<{
+    kind: "block-customize";
+    blockId: EditorBlockId;
+    requestId: number;
+}> | Readonly<{
+    kind: "linked-entry";
+    entryId: LinkedContentEntryId;
+    requestId: number;
+}>;
+export type LinkedEntryState = {
+    getSelectedEntryId: () => LinkedContentEntryId | null;
+    open: (target: {
+        entryId: string;
+        contentTypeKey: string;
+        contentTypeLabel: string;
+        title: string;
+        optimisticHash?: string | null;
+        content: Record<string, unknown>;
+        contentType: {
+            titleField?: string | null;
+            fields: readonly Record<string, unknown>[];
+        };
+    }) => void;
+    close: () => void;
+    discard: (entryId?: string) => void;
+    getSelectedSnapshot: () => EditorLinkedEntrySnapshot | null;
+    getSnapshot: (entryId?: string) => EditorLinkedEntrySnapshot | null;
+    inspect: () => readonly EditorLinkedEntrySnapshot[];
+    getCurrentValues: (entryId?: string) => Record<string, unknown> | null;
+    setCurrentValues: (values: Record<string, unknown> | null, entryId?: string) => void;
+    setAtPath: (path: string, value: unknown, entryId?: string) => void;
+    getAtPath: <R = unknown>(path: string, entryId?: string) => R | undefined;
+    saveSucceeded: (entryId: string, content: Record<string, unknown> | null, acknowledgement?: AutosaveAcknowledgement & {
+        optimisticHash?: string | null;
+    }) => void;
+    saveFailed: (entryId: string, message?: string) => void;
+    clearError: (entryId?: string) => void;
+};
+export type EditorPreviewInspectorStore = {
+    getState: () => {
+        drafts: Pick<DraftsState, "inspect">;
+        aiOverlays?: Readonly<{
+            viewMode: AiOverlaysState["viewMode"];
+            overrides: AiOverlaysState["overrides"];
+            structure?: AiOverlaysState["structure"];
+        }>;
+        linkedEntries: Pick<LinkedEntryState, "inspect">;
+    };
+};
 export type EditorHistoryState = HistoryState<EditorHistorySnapshot>;
 export type BlockValidationState = {
     markPathEdited: (blockId: EditorBlockId, path: string) => void;
@@ -112,11 +164,15 @@ type RestoreListener = (transition: {
 export type EditorUiState = {
     drawerOpen: boolean;
     previewSidebarTab: PreviewSidebarTab;
+    previewInspection: PreviewInspection;
     activePreviewField: ActivePreviewField;
     focusRequest: FocusRequest;
     activeBlockId: EditorBlockId | null;
     setDrawerOpen: (open: boolean) => void;
     setPreviewSidebarTab: (tab: PreviewSidebarTab) => void;
+    inspectBlock: (blockId: EditorBlockId) => void;
+    inspectLinkedEntry: (entryId: string) => void;
+    clearPreviewInspection: () => void;
     setActivePreviewField: (field: ActivePreviewField) => void;
     requestFocus: (payload: Omit<NonNullable<FocusRequest>, "requestId">) => void;
     clearFocus: () => void;
@@ -146,6 +202,7 @@ export type EditorUiState = {
     drafts: DraftsState;
     metadata: MetadataState;
     content: ContentState;
+    linkedEntries: LinkedEntryState;
     autosave: AutosaveState;
     arrayKeys: ArrayKeysState;
     viewport: ViewportState;