@riverbankcms/sdk 0.79.0 → 0.81.0

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;

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/builtins.d.ts

@@ -475,4 +475,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 {};

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

@@ -1,77 +1,113 @@
-type VisibilityRole = "admin" | "designer" | "author";
-type BlockManifestUi = {
-    showSlugPreview?: boolean;
-    showCharCount?: number | {
-        max: number;
-    };
-    visibleWhen?: {
-        field: string;
-        equals?: unknown;
-        notEquals?: unknown;
-        oneOf?: unknown[];
-        notIn?: unknown[];
-    };
+import type { ContentEntrySnapshot } from "./types";
+declare const nonEmptyPageRouteSlugBrand: unique symbol;
+export type NonEmptyPageRouteSlug = string & {
+    readonly [nonEmptyPageRouteSlugBrand]: "NonEmptyPageRouteSlug";
 };
-type BaseBlockManifestField = {
-    id: string;
+export type PageRouteSlug = Readonly<{
+    kind: "homepage";
+}> | Readonly<{
+    kind: "slug";
+    value: NonEmptyPageRouteSlug;
+}>;
+export type RouteMetadataManifestContext = Readonly<{
+    kind: "page";
+    routeSlug: PageRouteSlug;
+}> | Readonly<{
+    kind: "content";
+    typeKey?: string | null;
+}>;
+export type RouteMetadataPresentation = Readonly<{
+    kind: "page-homepage";
+    manifest: RouteMetadataManifest;
+    routeSlug: Extract<PageRouteSlug, {
+        kind: "homepage";
+    }>;
+}> | Readonly<{
+    kind: "page-routable";
+    manifest: RouteMetadataManifest;
+    routeSlug: Extract<PageRouteSlug, {
+        kind: "slug";
+    }>;
+}> | Readonly<{
+    kind: "content";
+    manifest: RouteMetadataManifest;
+    typeKey: string | null;
+}>;
+export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftStatus" | "scheduledPublishAt" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
+type RouteMetadataTextField = {
+    id: "draftTitle" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
+    type: "text";
     label: string;
     description?: string;
-    visibleRoles?: VisibilityRole[];
-    defaultValue?: unknown;
     required: boolean;
-    ui?: BlockManifestUi;
-};
-type TextBlockManifestField = BaseBlockManifestField & {
-    type: "text";
     multiline: boolean;
-    maxLength?: number;
+    ui?: {
+        showCharCount?: {
+            max: number;
+        };
+    };
 };
-type SlugBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataSlugField = {
+    id: "draftSlug";
     type: "slug";
-    sourceFieldId?: string;
-    statusFieldId?: string;
-    maxLength?: number;
+    label: string;
+    description: string;
+    required: true;
+    sourceFieldId?: "draftTitle";
+    statusFieldId: "draftStatus";
+    maxLength: number;
+    ui: {
+        showSlugPreview: true;
+    };
 };
-type SelectBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataSelectField = {
+    id: "draftStatus";
     type: "select";
+    label: string;
+    description: string;
+    required: true;
+    defaultValue: string;
     options: Array<{
         value: string;
         label: string;
-        description?: string;
-        icon?: string;
     }>;
-    multiple: boolean;
+    multiple: false;
 };
-type DateTimeBlockManifestField = BaseBlockManifestField & {
+type RouteMetadataDatetimeField = {
+    id: "scheduledPublishAt";
     type: "datetime";
-};
-type BlockManifestField = TextBlockManifestField | SlugBlockManifestField | SelectBlockManifestField | DateTimeBlockManifestField;
-type BlockManifestSlot = {
-    id: string;
     label: string;
-    allowedKinds: string[];
-    min: number;
-    max?: number;
-    help?: string;
-    visibleRoles?: VisibilityRole[];
+    description: string;
+    required: false;
+    ui: {
+        visibleWhen: {
+            field: "draftStatus";
+            equals: "scheduled";
+        };
+    };
 };
-type BlockManifest = {
+export type RouteMetadataField = RouteMetadataTextField | RouteMetadataSlugField | RouteMetadataSelectField | RouteMetadataDatetimeField;
+export type RouteMetadataManifest = {
     name: string;
     version: string;
     title: string;
     description: string;
     component: string;
-    fields: BlockManifestField[];
-    slots: BlockManifestSlot[];
+    fields: RouteMetadataField[];
+    slots: [];
 };
-export type RouteMetadataFieldId = "draftTitle" | "draftSlug" | "draftStatus" | "scheduledPublishAt" | "draftMetaTitle" | "draftMetaDescription" | "ogImageId";
-export declare const ROUTE_METADATA_MANIFEST: BlockManifest;
+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 course: readonly ["draftTitle", "draftSlug", "draftStatus", "scheduledPublishAt"];
@@ -82,13 +118,17 @@ export declare const ROUTE_METADATA_MANAGED_FIELDS_BY_TYPE: {
 export declare function getManagedRouteMetadataFieldIdsForType(typeKey: string | null | undefined): ReadonlyArray<RouteMetadataFieldId>;
 export declare function isRouteMetadataFieldEditableForType(typeKey: string | null | undefined, fieldId: string): boolean;
 export declare function getEditableRouteMetadataFieldIdsForType(typeKey: string | null | undefined): ReadonlyArray<RouteMetadataFieldId>;
-export declare function getRouteMetadataManifestForType(typeKey: string | null | undefined): BlockManifest;
+export declare function getRouteMetadataManifestForType(typeKey: string | null | undefined): RouteMetadataManifest;
+export declare function getRouteMetadataManifestForContext(context: RouteMetadataManifestContext): RouteMetadataManifest;
+export declare function deriveRouteMetadataPresentation(context: RouteMetadataManifestContext, options?: Readonly<{
+    omitTitle?: boolean;
+}>): RouteMetadataPresentation;
 /**
  * Remove the legacy route title editor from a route metadata manifest.
  *
  * Entry titles are now derived from entry data (single source of truth) and the route title is a denormalized copy.
  * We still keep `draftTitle` in the underlying manifest for page creation flows, but we omit it from entry editors.
  */
-export declare function omitRouteTitleFieldFromManifest(manifest: BlockManifest): BlockManifest;
+export declare function omitRouteTitleFieldFromManifest(manifest: RouteMetadataManifest): RouteMetadataManifest;
 export declare function sanitizeSlug(value: string): string;
 export {};

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

@@ -75,6 +75,8 @@ export type BookingCalendarFeedTokenPublicId = Brand<string, 'BookingCalendarFee
 export type BookingCalendarFeedTokenSecret = Brand<string, 'BookingCalendarFeedTokenSecret'>;
 export type BookingCalendarFeedTokenSecretHash = Brand<string, 'BookingCalendarFeedTokenSecretHash'>;
 export type ContentEntryId = Brand<string, 'ContentEntryId'>;
+export type ContentVersionId = Brand<string, 'ContentVersionId'>;
+export type EntryContentHash = Brand<string, 'EntryContentHash'>;
 export type StripeInvoiceId = Brand<string, 'StripeInvoiceId'>;
 export type NewsletterSubscriberId = Brand<string, 'NewsletterSubscriberId'>;
 export type NavigationMenuId = Brand<string, 'NavigationMenuId'>;
@@ -186,6 +188,8 @@ export declare const unsafeAsBookingCalendarFeedTokenPublicId: (id: string) => B
 export declare const unsafeAsBookingCalendarFeedTokenSecret: (value: string) => BookingCalendarFeedTokenSecret;
 export declare const unsafeAsBookingCalendarFeedTokenSecretHash: (value: string) => BookingCalendarFeedTokenSecretHash;
 export declare const unsafeAsContentEntryId: (id: string) => ContentEntryId;
+export declare const unsafeAsContentVersionId: (id: string) => ContentVersionId;
+export declare const unsafeAsEntryContentHash: (value: string) => EntryContentHash;
 export declare const unsafeAsStripeInvoiceId: (id: string) => StripeInvoiceId;
 export declare const unsafeAsNewsletterSubscriberId: (id: string) => NewsletterSubscriberId;
 export declare const unsafeAsNavigationMenuId: (id: string) => NavigationMenuId;
@@ -229,6 +233,7 @@ export declare const parseProductVariantId: (value: unknown) => Result<ProductVa
 export declare const parseProductCategoryId: (value: unknown) => Result<ProductCategoryId, BrandedIdParseError>;
 export declare const parseMediaAssetId: (value: unknown) => Result<MediaAssetId, BrandedIdParseError>;
 export declare const parseContentEntryId: (value: unknown) => Result<ContentEntryId, BrandedIdParseError>;
+export declare const parseContentVersionId: (value: unknown) => Result<ContentVersionId, BrandedIdParseError>;
 export declare const parseNavigationMenuId: (value: unknown) => Result<NavigationMenuId, BrandedIdParseError>;
 export declare const parseNavigationItemId: (value: unknown) => Result<NavigationItemId, BrandedIdParseError>;
 export declare const parsePassId: (value: unknown) => Result<PassId, BrandedIdParseError>;

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

@@ -41,5 +41,6 @@ export * from "./email-format";
 export * from "./slug";
 export * from "./string";
 export * from "./uuid";
+export * from "./stable-json";
 export { disabledSelection, enabledSelection, plannerNoChange, plannerPatch, plannerUpdate, resolvePlanningDateInput, resolvePlanningNow, resolvePlanningNowDate, systemPlanningClock, } from "./planner";
 export type { DisabledSelection, EnabledSelection, OptionalSelection, PlannerNoChange, PlannerPatch, PlannerUpdate, PlanningClock, PlanningDateInput, PlanningTimeOptions, } from "./planner";

package/dist/_dts/core/src/stable-json.d.ts

@@ -0,0 +1 @@
+export declare function stableJsonStringify(value: unknown): string;

package/dist/_dts/db/src/generated/supabase/database.types.d.ts

@@ -14162,7 +14162,9 @@ export type Database = {
                     last_success_at: string | null;
                     last_triggered_at: string | null;
                     name: string;
-                    secret: string;
+                    secret: string | null;
+                    secret_encrypted: string | null;
+                    secret_key_version: string | null;
                     site_id: string;
                     updated_at: string;
                     url: string;
@@ -14177,7 +14179,9 @@ export type Database = {
                     last_success_at?: string | null;
                     last_triggered_at?: string | null;
                     name?: string;
-                    secret: string;
+                    secret?: string | null;
+                    secret_encrypted?: string | null;
+                    secret_key_version?: string | null;
                     site_id: string;
                     updated_at?: string;
                     url: string;
@@ -14192,7 +14196,9 @@ export type Database = {
                     last_success_at?: string | null;
                     last_triggered_at?: string | null;
                     name?: string;
-                    secret?: string;
+                    secret?: string | null;
+                    secret_encrypted?: string | null;
+                    secret_key_version?: string | null;
                     site_id?: string;
                     updated_at?: string;
                     url?: string;

package/dist/_dts/editor/src/EditorProvider.d.ts

@@ -0,0 +1,26 @@
+import React, { type ReactNode } from 'react';
+export type DrawerFocusTarget = {
+    blockId: string | null;
+    fieldPath?: string | null;
+    itemIndex?: number | null;
+};
+export type DraftSyncState = 'baseline' | 'pending' | 'failed';
+interface EditorContextType {
+    isEditingMode: boolean;
+    toggleEditingMode: () => void;
+    setEditingMode: (value: boolean) => void;
+    editingElement: string | null;
+    setEditingElement: (elementId: string | null) => void;
+    currentBlockId?: string;
+    setCurrentBlock: (id: string | undefined) => void;
+    drawerFocus: DrawerFocusTarget | null;
+    setDrawerFocus: (target: DrawerFocusTarget | null) => void;
+    clearDrawerFocus: () => void;
+}
+export declare const useEditor: () => EditorContextType;
+interface EditorProviderProps {
+    children: ReactNode;
+    initialEditingMode?: boolean;
+}
+export declare const EditorProvider: React.FC<EditorProviderProps>;
+export {};

package/dist/_dts/editor/src/chrome/EditorChrome.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import { type EditorHistoryBarControls, type EditorStatusBarToolbar, type StatusBarMenuItem } from './EditorStatusBar';
+type EditorChromeProps = {
+    toolbarOverrides?: Partial<EditorStatusBarToolbar>;
+    onPublish?: () => void | Promise<void>;
+    onDiscard?: () => void | Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    messageOverride?: string | null;
+    messageVariant?: 'default' | 'manual-save';
+    actionButtonSize?: 'sm' | 'default' | 'lg';
+    showStatusBar?: boolean;
+    showToggle?: boolean;
+    /** Override kebab menu items; pass [] to hide menu entirely. */
+    menuItems?: StatusBarMenuItem[];
+    /** Add kebab menu items that only appear on mobile. */
+    mobileMenuItems?: StatusBarMenuItem[];
+    status?: 'idle' | 'saving' | 'success' | 'error';
+    lastSavedAt?: string | null;
+    draftSyncState?: 'baseline' | 'pending' | 'failed';
+    hasFailedSaves?: boolean;
+    onRetryFailedSaves?: () => void | Promise<void>;
+    historyControls?: EditorHistoryBarControls;
+};
+export declare function EditorChrome({ toolbarOverrides, onPublish, onDiscard, publishMenuItems, actionsSlot, messageOverride, messageVariant, actionButtonSize, showStatusBar, showToggle, menuItems: menuItemsOverride, mobileMenuItems, status, lastSavedAt, draftSyncState, hasFailedSaves, onRetryFailedSaves, historyControls, }: EditorChromeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/_dts/editor/src/chrome/EditorStatusBar.d.ts

@@ -0,0 +1,45 @@
+import { type ReactElement, type ReactNode } from "react";
+import type { DraftSyncState } from "../EditorProvider";
+export type DraftWorkflowStatus = "idle" | "saving" | "success" | "error";
+export type EditorStatusBarToolbar = {
+    publishLabel?: string;
+    hasUnpublishedChanges?: boolean;
+    disablePublish?: boolean;
+    disableDiscard?: boolean;
+    currentStatus?: string | null;
+    publishedMessage?: string | null;
+};
+export type EditorHistoryBarControls = {
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+};
+export type StatusBarMenuItem = {
+    label: string;
+    onClick: () => void;
+    variant?: "default" | "destructive";
+};
+export type EditorStatusBarProps = {
+    status: DraftWorkflowStatus;
+    lastSavedAt: string | null;
+    toolbar?: EditorStatusBarToolbar;
+    draftSyncState?: DraftSyncState;
+    onPublish?: () => void | Promise<void>;
+    onDiscard?: () => void | Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    toggleSlot?: ReactNode;
+    messageOverride?: string | null;
+    messageVariant?: "default" | "manual-save";
+    actionButtonSize?: "sm" | "default" | "lg";
+    hasFailedSaves?: boolean;
+    onRetryFailedSaves?: () => void | Promise<void>;
+    historyControls?: EditorHistoryBarControls;
+    secondaryMessage?: string | null;
+    /** Menu items for the kebab menu */
+    menuItems?: StatusBarMenuItem[];
+    /** Menu items that only appear in the mobile kebab menu. */
+    mobileMenuItems?: StatusBarMenuItem[];
+};
+export declare function EditorStatusBar({ status, lastSavedAt, toolbar, draftSyncState, onPublish, publishMenuItems, actionsSlot, toggleSlot, messageOverride, messageVariant, actionButtonSize, hasFailedSaves, onRetryFailedSaves, historyControls, secondaryMessage, menuItems, mobileMenuItems, }: EditorStatusBarProps): ReactElement;

package/dist/_dts/editor/src/chrome/statusBarPresentation.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { DraftSyncState } from '../EditorProvider';
+import type { DraftWorkflowStatus, EditorStatusBarProps, EditorStatusBarToolbar, StatusBarMenuItem } from './EditorStatusBar';
+export declare function getLatestSavedAt(values: readonly (string | null)[]): string | null;
+export type EditorStatusBarPresentationInput = Readonly<{
+    status: DraftWorkflowStatus;
+    lastSavedAt: string | null;
+    toolbar: EditorStatusBarToolbar;
+    draftSyncState: DraftSyncState;
+    hasFailedSaves: boolean;
+    errorMessage?: string | null;
+    unfinishedSummary: string | null;
+    canUndo: boolean;
+    canRedo: boolean;
+    onUndo: () => void;
+    onRedo: () => void;
+    onPublish?: () => Promise<void>;
+    onDiscard?: () => Promise<void>;
+    publishMenuItems?: StatusBarMenuItem[];
+    actionsSlot?: ReactNode;
+    menuItems?: StatusBarMenuItem[];
+    messageVariant: 'default' | 'manual-save';
+    actionButtonSize: 'sm' | 'default' | 'lg';
+}>;
+export declare function buildEditorStatusBarPresentationProps({ status, lastSavedAt, toolbar, draftSyncState, hasFailedSaves, errorMessage, unfinishedSummary, canUndo, canRedo, onUndo, onRedo, onPublish, onDiscard, publishMenuItems, actionsSlot, menuItems, messageVariant, actionButtonSize, }: EditorStatusBarPresentationInput): EditorStatusBarProps;

package/dist/_dts/editor/src/components/EditingToggle.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type EditingToggleProps = {
+    placement?: 'floating' | 'toolbar';
+};
+/**
+ * Toggle button for switching between edit and preview modes.
+ */
+export declare const EditingToggle: React.FC<EditingToggleProps>;
+export {};

package/dist/_dts/editor/src/hooks/useEditableElement.d.ts

@@ -0,0 +1,18 @@
+import { type KeyboardEvent } from 'react';
+export interface UseEditableElementOptions {
+    id: string;
+    value: string;
+    onChange: (value: string) => void;
+    onStartEdit?: () => void;
+    onEndEdit?: () => void;
+}
+export declare function useEditableElement({ id, onChange, onStartEdit, onEndEdit, }: UseEditableElementOptions): {
+    isEditingMode: boolean;
+    isEditing: boolean;
+    isHovered: boolean;
+    setIsHovered: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    editRef: import("react").RefObject<HTMLElement | null>;
+    handleStartEdit: () => void;
+    handleEndEdit: (newValue?: string) => void;
+    handleKeyDown: (e: KeyboardEvent) => void;
+};

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

@@ -0,0 +1,29 @@
+export { EditorChrome } from './chrome/EditorChrome';
+export { EditorStatusBar } from './chrome/EditorStatusBar';
+export { buildEditorStatusBarPresentationProps, getLatestSavedAt, } from './chrome/statusBarPresentation';
+export type { DraftWorkflowStatus, EditorHistoryBarControls, EditorStatusBarProps, EditorStatusBarToolbar, StatusBarMenuItem, } from './chrome/EditorStatusBar';
+export type { EditorStatusBarPresentationInput } from './chrome/statusBarPresentation';
+export { EditingToggle } from './components/EditingToggle';
+export { EditorProvider, useEditor } from './EditorProvider';
+export type { DraftSyncState, DrawerFocusTarget } from './EditorProvider';
+export { useEditableElement } from './hooks/useEditableElement';
+export type { UseEditableElementOptions } from './hooks/useEditableElement';
+export { InlineTextEditor } from './inline/InlineTextEditor';
+export { EditorPrimitivesProvider } from './primitives/EditorPrimitivesProvider';
+export type { InlineFieldAdapter } from './primitives/InlineFieldContext';
+export { deriveChannelId } from './primitives/helpers';
+export { richTextConfigs } from './primitives/rich-text/config';
+export type { RichTextEditorConfig, ToolbarButtonConfig, } from './primitives/rich-text/config';
+export { RichTextToolbar } from './primitives/rich-text/RichTextToolbar';
+export { RichTextEditorSurface } from './primitives/rich-text/RichTextEditorSurface';
+export type { RichTextRoutableItem } from './primitives/rich-text/toolbar/linkPopoverUtils';
+export { useRichTextEditor } from './primitives/rich-text/useRichTextEditor';
+export { buildRichTextImageAttrs, getRichTextImagePositionFromTarget, getSelectedRichTextImagePosition, insertOrReplaceRichTextImage, } from './primitives/rich-text/imageActions';
+export type { PickedRichTextImage } from './primitives/rich-text/imageActions';
+export { EMPTY_DOC, isDocEmpty, normaliseDoc, } from './primitives/rich-text/utils';
+export { formatUnsupportedRichTextSummary, hasUnsupportedRichTextContent, sanitizeRichTextContentForSchema, } from './primitives/rich-text/sanitize';
+export type { RichTextContentWarnings } from './primitives/rich-text/sanitize';
+export { EditorContent } from '@tiptap/react';
+export { EditorSaveProvider, useSaveField } from './primitives/SaveContext';
+export { createOptimisticTokenStore, OptimisticTokenStore, } from './utils/optimisticTokens';
+export type { OptimisticToken, OptimisticTokenSnapshot, } from './utils/optimisticTokens';

package/dist/_dts/editor/src/inline/InlineTextEditor.d.ts

@@ -0,0 +1 @@
+export declare const InlineTextEditor: () => import("react/jsx-runtime").JSX.Element;

package/dist/_dts/editor/src/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare function cn(...values: Array<string | false | null | undefined>): string;

package/dist/_dts/editor/src/primitives/EditorPrimitivesProvider.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { type InlineFieldAdapter } from './InlineFieldContext';
+type SaveArgs = {
+    path: string;
+    value: unknown;
+};
+type SaveFieldArgs = {
+    blockId: string;
+    path: string;
+    value: unknown;
+};
+type SaveFieldFn = (args: SaveFieldArgs) => Promise<unknown>;
+export declare function EditorPrimitivesProvider({ canEdit, saveField, onSave, inlineFieldAdapter, children, }: {
+    canEdit?: boolean;
+    saveField?: SaveFieldFn;
+    onSave?: (args: SaveArgs) => Promise<void>;
+    inlineFieldAdapter?: InlineFieldAdapter | null;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/_dts/editor/src/primitives/InlineFieldContext.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+export type InlineFieldAdapter = {
+    getValue: (path: string) => unknown;
+    setValue: (path: string, value: unknown) => void;
+    subscribe: (path: string, callback: () => void) => () => void;
+};
+export declare function InlineFieldProvider({ adapter, children, }: {
+    adapter?: InlineFieldAdapter | null;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useInlineFieldAdapter(): InlineFieldAdapter | null;