@riverbankcms/sdk 0.80.0 → 0.82.0

package/dist/_dts/content-editor/src/primitives/PreviewTextEditor.d.ts

@@ -1,4 +1,8 @@
 import type { TextProps } from '../../../blocks/src/index';
+import type { PreviewLinkedEntryFieldBinding } from '../../../blocks/src/system/data/index';
+type PreviewTextEditorProps = TextProps & {
+    onLinkedEntryFieldFocus?: (binding: PreviewLinkedEntryFieldBinding) => void;
+};
 /**
  * Inline text editor for preview mode with local authority.
  *
@@ -13,4 +17,5 @@ import type { TextProps } from '../../../blocks/src/index';
  *
  * This component mirrors PreviewRichTextEditor's pattern for consistency.
  */
-export declare function PreviewTextEditor(props: TextProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function PreviewTextEditor(props: PreviewTextEditorProps): import("react").JSX.Element | null;
+export {};

package/dist/_dts/content-editor/src/primitives/shared/activePreviewField.d.ts

@@ -1,4 +1,5 @@
 import type { ActivePreviewField } from '../../ui/editorUiStore';
+import type { PreviewLinkedEntryFieldBinding } from '../../../../blocks/src/system/data/index';
 /**
  * Returns true when the given editor path targets the same block-field that
  * the sidebar has currently focused (the "linked focus" affordance).
@@ -7,3 +8,4 @@ import type { ActivePreviewField } from '../../ui/editorUiStore';
  * primitives and tests share a single source of truth.
  */
 export declare function isLinkedSidebarField(editorPath: string, activeField: ActivePreviewField): boolean;
+export declare function isLinkedEntrySidebarField(binding: PreviewLinkedEntryFieldBinding | null | undefined, activeField: ActivePreviewField): boolean;

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

@@ -1,3 +1,3 @@
 export { parseEditorPath, useStoreBinding } from './storeBinding';
-export { isLinkedSidebarField } from './activePreviewField';
+export { isLinkedEntrySidebarField, isLinkedSidebarField } from './activePreviewField';
 export type { PathInfo } from './types';

package/dist/_dts/content-editor/src/primitives/shared/storeBinding.d.ts

@@ -1,3 +1,4 @@
+import type { PreviewLinkedEntryWriteBinding } from '../../../../blocks/src/system/data/index';
 import type { PathInfo } from './types';
 /**
  * Parse editor path into store and field components.
@@ -7,6 +8,7 @@ import type { PathInfo } from './types';
  * - metadata.<field> → metadata store (entry metadata editing)
  */
 export declare function parseEditorPath(path: string): PathInfo | null;
+export type StoreBindingInput = string | PreviewLinkedEntryWriteBinding;
 /**
  * Hook to bind to a store field via path.
  *
@@ -20,7 +22,7 @@ export declare function parseEditorPath(path: string): PathInfo | null;
  * @param path - Editor path (blocks.<id>.<field>, content.<field>, or metadata.<field>)
  * @returns {value, setValue, version, pathInfo}
  */
-export declare function useStoreBinding(path: string): {
+export declare function useStoreBinding(input: StoreBindingInput): {
     value: unknown;
     setValue: (value: unknown) => void;
     version: number;

package/dist/_dts/content-editor/src/primitives/shared/types.d.ts

@@ -1,4 +1,5 @@
 import type { EditorBlockId } from '../../ui/editorHistory';
+import type { LinkedContentEntryId } from '../../linkedEntries/domain';
 /**
  * Path information for store binding.
  * Supports three patterns:
@@ -16,4 +17,8 @@ export type PathInfo = {
 } | {
     store: 'metadata';
     field: string;
+} | {
+    store: 'linkedEntry';
+    entryId: LinkedContentEntryId;
+    field: string;
 };

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,22 +3,28 @@ 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";
-export type ActivePreviewField = Readonly<{
+export type ActivePreviewField = (Readonly<{
+    kind: "block";
     blockId: EditorBlockId;
     fieldPath: string;
-}> | null;
+}> | Readonly<{
+    kind: "linked-entry";
+    entryId: LinkedContentEntryId;
+    fieldPath: string;
+}>) | null;
 /**
  * Version of the local draft snapshot that a completed autosave request persisted.
  * The reducer uses this to accept the saved baseline without treating older
@@ -48,6 +54,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 +169,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 +207,7 @@ export type EditorUiState = {
     drafts: DraftsState;
     metadata: MetadataState;
     content: ContentState;
+    linkedEntries: LinkedEntryState;
     autosave: AutosaveState;
     arrayKeys: ArrayKeysState;
     viewport: ViewportState;

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

@@ -11,9 +11,11 @@ export type AutosaveState = {
     metadata: AutosaveStatus;
     content: AutosaveStatus;
     blocks: AutosaveStatus;
+    linkedEntries: AutosaveStatus;
     setMetadataStatus: (status: Partial<AutosaveStatus>) => void;
     setContentStatus: (status: Partial<AutosaveStatus>) => void;
     setBlocksStatus: (status: Partial<AutosaveStatus>) => void;
+    setLinkedEntriesStatus: (status: Partial<AutosaveStatus>) => void;
     registerAutosave: (type: AutosaveType, handle: AutosaveHandle) => void;
     unregisterAutosave: (type: AutosaveType) => void;
     /**

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

@@ -11,7 +11,7 @@ export type AutosaveHandle = {
     flush: () => void;
     isPending: () => boolean;
 };
-export type AutosaveType = 'metadata' | 'content' | 'blocks';
+export type AutosaveType = 'metadata' | 'content' | 'blocks' | 'linkedEntries';
 export type FocusRequest = {
     requestId: number;
     blockId: EditorBlockId;

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

@@ -65,21 +65,6 @@ export declare const EVENT_CONTENT_TYPE_SCHEMA: {
         readonly type: "media";
         readonly label: "Listing image";
         readonly description: "Optional image used for event cards and previews.";
-    }, {
-        readonly id: "tags";
-        readonly type: "text";
-        readonly label: "Tags";
-        readonly description: "Comma-separated tags for event listings.";
-    }, {
-        readonly id: "badges";
-        readonly type: "text";
-        readonly label: "Badges";
-        readonly description: "Comma-separated badges shown on event cards.";
-    }, {
-        readonly id: "ctaLabel";
-        readonly type: "text";
-        readonly label: "CTA label";
-        readonly description: "Optional call-to-action label for event cards.";
     }, {
         readonly id: "body";
         readonly type: "richText";
@@ -115,21 +100,6 @@ export declare const COURSE_CONTENT_TYPE_SCHEMA: {
         readonly type: "media";
         readonly label: "Listing image";
         readonly description: "Optional image used for course cards and previews.";
-    }, {
-        readonly id: "tags";
-        readonly type: "text";
-        readonly label: "Tags";
-        readonly description: "Comma-separated tags for course listings.";
-    }, {
-        readonly id: "badges";
-        readonly type: "text";
-        readonly label: "Badges";
-        readonly description: "Comma-separated badges shown on course cards.";
-    }, {
-        readonly id: "ctaLabel";
-        readonly type: "text";
-        readonly label: "CTA label";
-        readonly description: "Optional call-to-action label for course cards.";
     }, {
         readonly id: "body";
         readonly type: "richText";
@@ -222,16 +192,6 @@ export declare const PRODUCT_CONTENT_TYPE_SCHEMA: {
         readonly type: "media";
         readonly label: "Listing image";
         readonly description: "Optional image used for product cards and previews.";
-    }, {
-        readonly id: "badges";
-        readonly type: "text";
-        readonly label: "Badges";
-        readonly description: "Comma-separated badges shown on product cards.";
-    }, {
-        readonly id: "ctaLabel";
-        readonly type: "text";
-        readonly label: "CTA label";
-        readonly description: "Optional call-to-action label for product cards.";
     }, {
         readonly id: "body";
         readonly type: "richText";

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

@@ -182,21 +182,6 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
             readonly type: "media";
             readonly label: "Listing image";
             readonly description: "Optional image used for event cards and previews.";
-        }, {
-            readonly id: "tags";
-            readonly type: "text";
-            readonly label: "Tags";
-            readonly description: "Comma-separated tags for event listings.";
-        }, {
-            readonly id: "badges";
-            readonly type: "text";
-            readonly label: "Badges";
-            readonly description: "Comma-separated badges shown on event cards.";
-        }, {
-            readonly id: "ctaLabel";
-            readonly type: "text";
-            readonly label: "CTA label";
-            readonly description: "Optional call-to-action label for event cards.";
         }, {
             readonly id: "body";
             readonly type: "richText";
@@ -232,21 +217,6 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
             readonly type: "media";
             readonly label: "Listing image";
             readonly description: "Optional image used for course cards and previews.";
-        }, {
-            readonly id: "tags";
-            readonly type: "text";
-            readonly label: "Tags";
-            readonly description: "Comma-separated tags for course listings.";
-        }, {
-            readonly id: "badges";
-            readonly type: "text";
-            readonly label: "Badges";
-            readonly description: "Comma-separated badges shown on course cards.";
-        }, {
-            readonly id: "ctaLabel";
-            readonly type: "text";
-            readonly label: "CTA label";
-            readonly description: "Optional call-to-action label for course cards.";
         }, {
             readonly id: "body";
             readonly type: "richText";
@@ -339,16 +309,6 @@ export declare const BUILTIN_CONTENT_TYPE_SCHEMAS: {
             readonly type: "media";
             readonly label: "Listing image";
             readonly description: "Optional image used for product cards and previews.";
-        }, {
-            readonly id: "badges";
-            readonly type: "text";
-            readonly label: "Badges";
-            readonly description: "Comma-separated badges shown on product cards.";
-        }, {
-            readonly id: "ctaLabel";
-            readonly type: "text";
-            readonly label: "CTA label";
-            readonly description: "Optional call-to-action label for product cards.";
         }, {
             readonly id: "body";
             readonly type: "richText";
@@ -475,4 +435,47 @@ export declare const BUILTIN_CONTENT_TYPE_FIELD_IDS: {
     readonly page: ReadonlySet<string>;
     readonly 'product-category': ReadonlySet<string>;
 };
+export type BuiltinPreviewLinkedEntryEditing = Readonly<{
+    kind: 'generic';
+}> | Readonly<{
+    kind: 'unsupported-domain-backed';
+    reason: string;
+}>;
+/**
+ * Preview editing support for built-in content entries when they appear as
+ * linked data inside a block. Generic editorial content can use the shared
+ * content-entry form; domain-backed content stays closed until its workflow
+ * can preserve domain invariants such as occurrences, booking, or commerce.
+ */
+export declare const BUILTIN_PREVIEW_LINKED_ENTRY_EDITING: {
+    readonly post: {
+        readonly kind: "generic";
+    };
+    readonly event: {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+    readonly course: {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+    readonly 'team-member': {
+        readonly kind: "generic";
+    };
+    readonly product: {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+    readonly testimonial: {
+        readonly kind: "generic";
+    };
+    readonly page: {
+        readonly kind: "generic";
+    };
+    readonly 'product-category': {
+        readonly kind: "unsupported-domain-backed";
+        readonly reason: "Domain-backed entries need a dedicated editor workflow.";
+    };
+};
+export declare function getBuiltinPreviewLinkedEntryEditing(key: string): BuiltinPreviewLinkedEntryEditing | null;
 export {};