@riverbankcms/sdk 0.62.2 → 0.64.0

package/dist/_dts/preview-next/src/client/preview/previewCustomizeRuntimePatch.d.ts

@@ -1,4 +1,4 @@
-import { type PageDesignEditorReadModel } from '@riverbankcms/theme-core/site-styles/previewCompiler';
+import type { PageDesignEditorReadModel } from '@riverbankcms/theme-core/site-styles/previewCompiler';
 import type { DesignBlockId } from '@riverbankcms/theme-core/site-styles';
 import type { PreviewCustomizeAction } from '../blocks/previewCustomizeActions';
 export type PreviewEditorRuntimeContent = Record<string, unknown>;
@@ -8,6 +8,14 @@ export type PreviewCustomizeRuntimePatch = Readonly<{
     nextContent: PreviewEditorRuntimeContent;
     rollback: (currentContent: PreviewEditorRuntimeContent) => PreviewEditorRuntimeContent;
 }>;
+export type PreviewCustomizeActionDomain = Readonly<{
+    kind: 'block-content-write';
+}> | Readonly<{
+    kind: 'page-design-write';
+}> | Readonly<{
+    kind: 'render-only-preview';
+}>;
+export declare function classifyPreviewCustomizeActionDomain(action: PreviewCustomizeAction): PreviewCustomizeActionDomain;
 export declare function derivePreviewCustomizeRuntimePatch(input: Readonly<{
     action: PreviewCustomizeAction;
     editorModel: PageDesignEditorReadModel;

package/dist/_dts/preview-next/src/client/preview/previewCustomizeWorkflowState.d.ts

@@ -20,6 +20,9 @@ export type PreviewPageDesignEditorState = Readonly<{
 export type PreviewPageDesignEditorApplyOutcome = Readonly<{
     kind: 'saved';
     response: ApplyPageDesignEditorActionResponse;
+}> | Readonly<{
+    kind: 'queued';
+    message: string;
 }> | Readonly<{
     kind: 'skipped';
     reason: PreviewCustomizeSkipReason;
@@ -37,10 +40,14 @@ export type PreviewPageDesignEditorApplyOutcome = Readonly<{
 export type PreviewCustomizeSkipReason = 'disabled' | 'missing-page' | 'not-loaded' | 'mutation-pending' | 'stale' | 'no-history-entry' | 'cannot-undo' | 'cannot-redo';
 export type PreviewCustomizeMutationState = Readonly<{
     kind: 'idle';
+}> | Readonly<{
+    kind: 'dirty';
+    actions: readonly PreviewCustomizePendingAction[];
 }> | Readonly<{
     kind: 'applying';
     action: PreviewCustomizeAction;
     historyEntry: PreviewCustomizeHistoryEntry | null;
+    queuedActions: readonly PreviewCustomizePendingAction[];
 }> | Readonly<{
     kind: 'undoing';
     action: PreviewCustomizeAction;
@@ -72,6 +79,10 @@ export type PreviewCustomizeWorkflowState = Readonly<{
     history: PreviewCustomizeHistoryState;
     mutation: PreviewCustomizeMutationState;
 }>;
+type PreviewCustomizePendingAction = Readonly<{
+    action: PreviewCustomizeAction;
+    historyEntry: PreviewCustomizeHistoryEntry | null;
+}>;
 export type PreviewCustomizeBeginResult = Readonly<{
     kind: 'started';
     state: PreviewCustomizeWorkflowState;
@@ -87,6 +98,7 @@ export declare function failedPreviewCustomizeWorkflowState(message: string): Pr
 export declare function previewCustomizeLoadSucceeded(pageState: ApiPageDesignEditorStateResponse): PreviewCustomizeWorkflowState;
 export declare function previewCustomizeWorkflowPageState(workflow: PreviewCustomizeWorkflowState): PreviewPageDesignEditorState;
 export declare function beginPreviewCustomizeApply(workflow: PreviewCustomizeWorkflowState, action: PreviewCustomizeAction): PreviewCustomizeBeginResult;
+export declare function beginPreviewCustomizeAutosave(workflow: PreviewCustomizeWorkflowState): PreviewCustomizeBeginResult;
 export declare function beginPreviewCustomizeUndo(workflow: PreviewCustomizeWorkflowState): PreviewCustomizeBeginResult;
 export declare function beginPreviewCustomizeRedo(workflow: PreviewCustomizeWorkflowState): PreviewCustomizeBeginResult;
 export declare function confirmPreviewCustomizeMutation(workflow: PreviewCustomizeWorkflowState, response: ApplyPageDesignEditorActionResponse): PreviewCustomizeWorkflowState;
@@ -103,4 +115,5 @@ export declare function applyPreviewCustomizeActionToState(state: PreviewPageDes
 export declare function skippedPreviewCustomizeOutcome(reason: PreviewCustomizeSkipReason): Extract<PreviewPageDesignEditorApplyOutcome, {
     kind: 'skipped';
 }>;
+export declare function previewCustomizePendingActions(workflow: PreviewCustomizeWorkflowState): readonly PreviewCustomizeAction[];
 export {};

package/dist/_dts/preview-next/src/client/preview/sidebarTabPreference.d.ts

@@ -1,6 +1,12 @@
 import type { PreviewSidebarTab } from '@riverbankcms/content-editor';
 export type { PreviewSidebarTab };
+export type PreviewDesignRow = 'header' | 'footer';
+export type PreviewSidebarOpenRequest = Readonly<{
+    tab: PreviewSidebarTab;
+    designRow?: PreviewDesignRow;
+}>;
+export declare function parsePreviewSidebarOpenRequestDetail(detail: unknown): PreviewSidebarOpenRequest;
 export declare function getPreviewSidebarTab(): PreviewSidebarTab;
 export declare function setPreviewSidebarTab(tab: PreviewSidebarTab): void;
-export declare function requestPreviewSidebarOpen(tab: PreviewSidebarTab): void;
-export declare function onPreviewSidebarOpenRequest(handler: (tab: PreviewSidebarTab) => void): () => void;
+export declare function requestPreviewSidebarOpen(input: PreviewSidebarTab | PreviewSidebarOpenRequest): void;
+export declare function onPreviewSidebarOpenRequest(handler: (request: PreviewSidebarOpenRequest) => void): () => void;

package/dist/_dts/preview-next/src/client/preview/siteChromeLookRows.d.ts

@@ -0,0 +1,49 @@
+import { type CuratedSiteStyle } from '@riverbankcms/theme-core/site-styles/previewCompiler';
+import { type FooterLookId, type FooterSelectionContext, type HeaderLookId, type HeaderSelectionContext, type LookCustomizationWritePlan } from '@riverbankcms/theme-core/site-styles';
+import type { SelectionSnapshot, StyleConfiguratorState } from './StyleConfigurator.state';
+export type SiteChromeLookOption<TId extends string | null> = Readonly<{
+    id: TId;
+    label: string;
+    description?: string;
+    available: boolean;
+}>;
+export type SiteChromeLookCatalogOption<TId extends string> = Readonly<{
+    id: TId;
+    label: string;
+}>;
+export type SiteChromeLookRowModel<TId extends string> = Readonly<{
+    options: readonly SiteChromeLookOption<TId | null>[];
+    diagnostics: readonly string[];
+    renderedLookId: TId;
+}>;
+export type SiteChromeLookModels = Readonly<{
+    header: SiteChromeLookRowModel<HeaderLookId>;
+    footer: SiteChromeLookRowModel<FooterLookId>;
+}>;
+type SiteChromeLookModelInput = Readonly<{
+    state: StyleConfiguratorState;
+    siteStyle: CuratedSiteStyle;
+    headerSelectionContext?: Partial<HeaderSelectionContext>;
+    footerSelectionContext?: Partial<FooterSelectionContext>;
+}>;
+export declare function buildSiteChromeLookModels(input: SiteChromeLookModelInput): SiteChromeLookModels;
+export declare function cycleSiteChromeLookId<TId extends string>(options: readonly SiteChromeLookOption<TId | null>[], currentId: TId | null, direction: 'prev' | 'next'): TId | null | undefined;
+export declare function cycleableSiteChromeOptions<TId extends string>(options: readonly SiteChromeLookOption<TId | null>[]): readonly SiteChromeLookOption<TId | null>[];
+export type SiteChromeLookSelectionCommand = Readonly<{
+    surface: 'header';
+    lookId: HeaderLookId | null;
+}> | Readonly<{
+    surface: 'footer';
+    lookId: FooterLookId | null;
+}>;
+export type SiteChromeLookSelectionPlan = Readonly<{
+    kind: 'header';
+    writePlan: LookCustomizationWritePlan<HeaderLookId>;
+    next: Pick<SelectionSnapshot, 'headerLookId'>;
+}> | Readonly<{
+    kind: 'footer';
+    writePlan: LookCustomizationWritePlan<FooterLookId>;
+    next: Pick<SelectionSnapshot, 'footerLookId'>;
+}>;
+export declare function planSiteChromeLookSelection(command: SiteChromeLookSelectionCommand): SiteChromeLookSelectionPlan;
+export {};

package/dist/_dts/preview-next/src/client/preview/styleConfiguratorSnapshot.d.ts

@@ -0,0 +1,18 @@
+import type { Theme } from '@riverbankcms/blocks';
+import type { ButtonPersonalityId } from '@riverbankcms/theme-core/buttons';
+import type { PaletteOverrides, PaletteVariantId } from '@riverbankcms/theme-core/palette';
+import type { FooterLookId, FooterSelectionContext, HeaderLookId, HeaderSelectionContext } from '@riverbankcms/theme-core/site-styles';
+import type { SelectionSnapshot } from './StyleConfigurator.state';
+export declare function resolveStyleConfiguratorInitialSnapshot(input: Readonly<{
+    theme?: Theme | null;
+    initialSelections: Readonly<{
+        selectionUpdatedAt?: string | null;
+        buttonPersonalityId: ButtonPersonalityId | null;
+        paletteVariantId: PaletteVariantId | null;
+        paletteOverrides: PaletteOverrides | null;
+        headerLookId?: HeaderLookId | null;
+        footerLookId?: FooterLookId | null;
+    }>;
+    headerSelectionContext?: Partial<HeaderSelectionContext>;
+    footerSelectionContext?: Partial<FooterSelectionContext>;
+}>): SelectionSnapshot | null;

package/dist/_dts/sdk/src/cli/commands/pull.d.ts

@@ -16,6 +16,11 @@
  */
 import { Command } from 'commander';
 import type { PulledContent } from '../../client/management';
+import type { EntryBaseSnapshotTarget } from '../merge-remote/entrySnapshots';
+export declare function entryBaseSnapshotTargetForPull(input: Readonly<{
+    isRemote: boolean;
+    siteId: string;
+}>): EntryBaseSnapshotTarget;
 export declare function createScopedPullContent(meta: PulledContent['meta'], overrides: Partial<Omit<PulledContent, 'meta'>>): PulledContent;
 /**
  * Determines whether the pull command should prompt for overwrite confirmation.

package/dist/_dts/sdk/src/cli/commands/push/options.d.ts

@@ -16,6 +16,8 @@ export interface PushOptions {
     deleteOrphaned?: boolean;
     /** Automatically pull stale content and retry push instead of aborting */
     autoPullStale?: boolean;
+    /** Use three-way merge bases to preserve remote entry edits during entries pushes */
+    mergeRemote?: boolean;
     /** Skip writing .meta/*.json and media/.manifest.json (Commander --no-meta sets this to false) */
     meta?: boolean;
     /** Show human-readable field-level diff (requires --dry-run) */

package/dist/_dts/sdk/src/cli/commands/push-execute.d.ts

@@ -5,6 +5,22 @@ import type { PushOptions } from './push/options';
 export interface PushExecutionResult {
     success: boolean;
 }
+type MergeRemoteValidationInput = Readonly<{
+    target: EnvTarget;
+    pushScope: string;
+    contentType?: string;
+    identifier?: string;
+    force: boolean;
+    deleteOrphaned: boolean;
+    autoPullStale: boolean;
+}>;
+type MergeRemoteValidationError = Readonly<{
+    message: string;
+    details: Readonly<{
+        suggestion: string;
+    }>;
+}>;
+export declare function validateMergeRemoteEntryPushOptions(input: MergeRemoteValidationInput): MergeRemoteValidationError | null;
 /**
  * Execute push for a single environment.
  * Extracted to support --env=both multi-environment operations.
@@ -15,3 +31,4 @@ export declare function executePushForEnv(output: OutputContext, target: EnvTarg
 }, globalOpts: {
     json?: boolean;
 }): Promise<PushExecutionResult>;
+export {};

package/dist/_dts/sdk/src/cli/content/entryPaths.d.ts

@@ -0,0 +1,6 @@
+export declare function entryTypeDirPath(contentDir: string, contentType: string): string;
+export declare function entryFilePath(input: Readonly<{
+    contentDir: string;
+    contentType: string;
+    identifier: string;
+}>): string;

package/dist/_dts/sdk/src/cli/content/writer.d.ts

@@ -5,9 +5,11 @@
  */
 import type { PulledEntries, PulledPages, PulledNavigation, PulledSettings, PulledForms, PulledTheme, PulledFooter, PulledVenues, PulledEventCategories, PulledEvents, PulledCourses } from '../../client/management/types';
 import type { Theme } from '../../contracts';
+import type { EntryBaseSnapshotTarget } from '../merge-remote/entrySnapshots';
 export interface WriterOptions {
     skipMeta?: boolean;
     cleanupMissing?: boolean;
+    entryBaseSnapshot?: EntryBaseSnapshotTarget;
 }
 /**
  * Write entries to content directory

package/dist/_dts/sdk/src/cli/merge-remote/entryLocal.d.ts

@@ -0,0 +1,3 @@
+import type { PulledEntries } from '../../client/management/types';
+import type { LocalEntry } from '../content/reader';
+export declare function pulledEntryToLocalEntry(entry: PulledEntries['entries'][number]): LocalEntry;

package/dist/_dts/sdk/src/cli/merge-remote/entryMerge.d.ts

@@ -0,0 +1,77 @@
+import type { LocalEntry } from '../content/reader';
+export type EntryMergeSubject = Readonly<{
+    contentType: string;
+    identifier: string;
+}>;
+export type EntryMergeInputs = Readonly<{
+    subject: EntryMergeSubject;
+    base: LocalEntry | null;
+    local: LocalEntry | null;
+    remote: LocalEntry | null;
+}>;
+export type EntryMergeConflict = Readonly<{
+    code: 'missing_base';
+    subject: EntryMergeSubject;
+    message: string;
+}> | Readonly<{
+    code: 'same_field_changed';
+    subject: EntryMergeSubject;
+    fieldPath: string;
+    message: string;
+}> | Readonly<{
+    code: 'local_delete_remote_edit';
+    subject: EntryMergeSubject;
+    message: string;
+}> | Readonly<{
+    code: 'remote_delete_local_edit';
+    subject: EntryMergeSubject;
+    message: string;
+}> | Readonly<{
+    code: 'unsupported_nested_merge';
+    subject: EntryMergeSubject;
+    fieldPath: string;
+    message: string;
+}>;
+export type EntryMergeDecision = Readonly<{
+    kind: 'unchanged';
+    subject: EntryMergeSubject;
+    desired: LocalEntry | null;
+}> | Readonly<{
+    kind: 'bootstrap_base';
+    subject: EntryMergeSubject;
+    desired: LocalEntry;
+}> | Readonly<{
+    kind: 'preserve_remote';
+    subject: EntryMergeSubject;
+    desired: LocalEntry | null;
+}> | Readonly<{
+    kind: 'apply_local_create' | 'apply_local_update';
+    subject: EntryMergeSubject;
+    desired: LocalEntry;
+}> | Readonly<{
+    kind: 'apply_local_delete';
+    subject: EntryMergeSubject;
+    desired: null;
+}> | Readonly<{
+    kind: 'auto_merge';
+    subject: EntryMergeSubject;
+    desired: LocalEntry;
+    localFieldPaths: readonly string[];
+    remoteFieldPaths: readonly string[];
+}> | Readonly<{
+    kind: 'conflict';
+    subject: EntryMergeSubject;
+    conflict: EntryMergeConflict;
+}>;
+export type ComparableEntry = Readonly<{
+    identifier: string;
+    slug?: string;
+    status?: LocalEntry['status'];
+    hasUnpublishedChanges?: boolean;
+    data: Readonly<Record<string, unknown>>;
+}>;
+export type ComparableEntryContent = Pick<ComparableEntry, 'identifier' | 'slug' | 'data'>;
+export declare function planEntryMerge(input: EntryMergeInputs): EntryMergeDecision;
+export declare function comparableEntry(entry: LocalEntry | null): ComparableEntry | null;
+export declare function comparableEntryContent(entry: LocalEntry | null): ComparableEntryContent | null;
+export declare function entryContentsEqual(left: LocalEntry | null, right: LocalEntry | null): boolean;

package/dist/_dts/sdk/src/cli/merge-remote/entryMergePlan.d.ts

@@ -0,0 +1,45 @@
+import type { PulledEntries } from '../../client/management/types';
+import type { LocalEntry } from '../content/reader';
+import { type EntryBaseSnapshotTarget } from './entrySnapshots';
+import { type EntryMergeDecision } from './entryMerge';
+export type EntryMergePushScope = Readonly<{
+    kind: 'all_entries';
+}> | Readonly<{
+    kind: 'content_type';
+    contentType: string;
+}> | Readonly<{
+    kind: 'single_entry';
+    contentType: string;
+    identifier: string;
+}>;
+export type RemoteEntryMergePlan = Readonly<{
+    scope: EntryMergePushScope;
+    decisions: readonly EntryMergeDecision[];
+    summary: RemoteEntryMergePlanSummary;
+}>;
+export type RemoteEntryMergePlanSummary = Readonly<{
+    unchanged: number;
+    bootstrapBase: number;
+    preserveRemote: number;
+    applyLocalCreate: number;
+    applyLocalUpdate: number;
+    applyLocalDelete: number;
+    autoMerge: number;
+    conflicts: number;
+}>;
+export type RemoteEntryMergePlanInput = Readonly<{
+    contentDir: string;
+    target: EntryBaseSnapshotTarget;
+    scope: EntryMergePushScope;
+    localEntries: ReadonlyMap<string, readonly LocalEntry[]>;
+    remoteEntries: RemoteEntriesByType;
+}>;
+export type RemoteEntriesByType = ReadonlyMap<string, ReadonlyArray<PulledEntries['entries'][number]>>;
+export declare function buildRemoteEntryMergePlan(input: RemoteEntryMergePlanInput): Promise<RemoteEntryMergePlan>;
+export declare function summarizeEntryMergeDecisions(decisions: readonly EntryMergeDecision[]): RemoteEntryMergePlanSummary;
+export declare function entryMergePushScope(input: Readonly<{
+    contentType?: string;
+    identifier?: string;
+}>): EntryMergePushScope;
+export declare function remotePulledEntriesByType(entries: Readonly<Record<string, PulledEntries['entries']>>): RemoteEntriesByType;
+export declare function pulledEntriesToRemoteByType(contentType: string, entries: PulledEntries['entries']): RemoteEntriesByType;

package/dist/_dts/sdk/src/cli/merge-remote/entryMergePush.d.ts

@@ -0,0 +1,21 @@
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalEntry } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { OutputContext } from '../output';
+export type RemoteEntryMergePushResult = Readonly<{
+    success: boolean;
+}>;
+export declare function planAndReportRemoteEntryMerge(input: Readonly<{
+    output: OutputContext;
+    client: Pick<ManagementClient, 'entries' | 'pull'>;
+    contentDir: string;
+    target: EnvTarget;
+    siteId: string;
+    contentType?: string;
+    identifier?: string;
+    localEntries: ReadonlyMap<string, readonly LocalEntry[]>;
+    dryRun: boolean;
+    jsonOutput: boolean;
+    jsonDiff: boolean;
+    skipMeta: boolean;
+}>): Promise<RemoteEntryMergePushResult>;

package/dist/_dts/sdk/src/cli/merge-remote/entryMergeReport.d.ts

@@ -0,0 +1,30 @@
+import type { OutputContext } from '../output';
+import type { EntryMergeConflict, EntryMergeDecision } from './entryMerge';
+import type { RemoteEntryMergePlan } from './entryMergePlan';
+export type RemoteEntryMergeJsonReport = Readonly<{
+    kind: 'push';
+    scope: 'entries';
+    mergeRemote: true;
+    dryRun: boolean;
+    summary: RemoteEntryMergePlan['summary'];
+    decisions: readonly RemoteEntryMergeDecisionReport[];
+}>;
+export type RemoteEntryMergeDecisionReport = Readonly<{
+    kind: EntryMergeDecision['kind'];
+    contentType: string;
+    identifier: string;
+    localFieldPaths?: readonly string[];
+    remoteFieldPaths?: readonly string[];
+    conflict?: Readonly<{
+        code: EntryMergeConflict['code'];
+        fieldPath?: string;
+        message: string;
+    }>;
+}>;
+export declare function remoteEntryMergeJsonReport(input: Readonly<{
+    plan: RemoteEntryMergePlan;
+    dryRun: boolean;
+}>): RemoteEntryMergeJsonReport;
+export declare function writeRemoteEntryMergeHumanReport(output: Pick<OutputContext, 'info'>, plan: RemoteEntryMergePlan, options: Readonly<{
+    dryRun: boolean;
+}>): void;

package/dist/_dts/sdk/src/cli/merge-remote/entryRemote.d.ts

@@ -0,0 +1,9 @@
+import type { ManagementClient, PulledEntries } from '../../client/management/types';
+import type { OutputContext } from '../output';
+import { type EntryMergePushScope, type RemoteEntriesByType } from './entryMergePlan';
+export declare function fetchRemoteEntriesForMerge(input: Readonly<{
+    client: Pick<ManagementClient, 'pull'>;
+    scope: EntryMergePushScope;
+    output: Pick<OutputContext, 'info' | 'warn'>;
+}>): Promise<RemoteEntriesByType>;
+export declare function fetchRemotePulledEntriesForContentType(client: Pick<ManagementClient, 'pull'>, contentType: string, output: Pick<OutputContext, 'info'>): Promise<PulledEntries>;

package/dist/_dts/sdk/src/cli/merge-remote/entrySnapshots.d.ts

@@ -0,0 +1,50 @@
+import type { PulledEntries } from '../../client/management/types';
+import type { EnvTarget } from '../helpers';
+import type { LocalEntry } from '../content/reader';
+export type EntryBaseSnapshotTarget = Readonly<{
+    env: EnvTarget;
+    siteId: string;
+}>;
+export type EntryBaseSnapshotSubject = Readonly<{
+    contentType: string;
+    identifier: string;
+}>;
+export type EntryBaseSnapshot = Readonly<{
+    version: 'entry-base.v1';
+    target: Readonly<{
+        env: EnvTarget;
+        siteIdHash: string;
+    }>;
+    subject: EntryBaseSnapshotSubject;
+    pulledAt: string;
+    remoteVersion: Readonly<{
+        createdAt?: string;
+        updatedAt?: string;
+        publishedAt?: string | null;
+    }>;
+    entry: LocalEntry;
+}>;
+export type WriteEntryBaseSnapshotsInput = Readonly<{
+    contentDir: string;
+    target: EntryBaseSnapshotTarget;
+    contentType: string;
+    entries: PulledEntries['entries'];
+    meta: PulledEntries['meta'];
+    cleanupMissing?: boolean;
+}>;
+export type WriteEntryBaseSnapshotsResult = Readonly<{
+    rootDir: string;
+    count: number;
+}>;
+export declare function entryBaseSnapshotRoot(contentDir: string): string;
+export declare function entryBaseSnapshotPath(input: Readonly<{
+    contentDir: string;
+    target: EntryBaseSnapshotTarget;
+    subject: EntryBaseSnapshotSubject;
+}>): string;
+export declare function writeEntryBaseSnapshots(input: WriteEntryBaseSnapshotsInput): Promise<WriteEntryBaseSnapshotsResult>;
+export declare function readEntryBaseSnapshot(input: Readonly<{
+    contentDir: string;
+    target: EntryBaseSnapshotTarget;
+    subject: EntryBaseSnapshotSubject;
+}>): Promise<EntryBaseSnapshot | null>;

package/dist/_dts/sdk/src/cli/merge-remote/stableJson.d.ts

@@ -0,0 +1,3 @@
+export declare function stableStringify(value: unknown): string;
+export declare function sortValue(value: unknown): unknown;
+export declare function sortRecord(record: Record<string, unknown>): Record<string, unknown>;

package/dist/_dts/sdk/src/cli/site-commands/entryCommands.d.ts

@@ -0,0 +1,85 @@
+import { type Result } from '@riverbankcms/core';
+import { type AllowedRuntime, type DryRunReport, type PlannedSiteCommandFor, type SiteCommandBatch, type SiteCommandExecutionSuccess, type SiteCommandOf, type SiteCommandPlan, type SiteCommandRef, type SiteCommandValidationError } from '@riverbankcms/site-commands';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { ContentDiff } from '../sync/diff';
+import { type SyncResult } from '../sync';
+export type CliEntryCommandBatchSource = 'push_entries' | 'merge_remote_entries';
+export type CliCommandCompileError = Readonly<{
+    code: 'missing_local_entry';
+    contentType: string;
+    identifier: string;
+    message: string;
+}> | Readonly<{
+    code: 'command_validation_failed';
+    errors: readonly SiteCommandValidationError[];
+    message: string;
+}>;
+export type CliEntryCommandCompileInput = Readonly<{
+    source: CliEntryCommandBatchSource;
+    siteId: string;
+    targetEnv: EnvTarget;
+    diff: Pick<ContentDiff, 'entries'>;
+    local: Pick<LocalContent, 'entries'>;
+}>;
+export type CliEntryCommandCompileSuccess = Readonly<{
+    batch: SiteCommandBatch;
+    plan: EntrySiteCommandPlan;
+    dryRunReport: DryRunReport;
+    reportSubjectsByCommandRef: EntryCommandReportSubjectsByRef;
+}>;
+export type CliEntryCommandExecutionError = Readonly<{
+    code: 'management_api_failed';
+    commandRef: SiteCommandRef;
+    commandType: EntrySiteCommandType;
+    message: string;
+}>;
+export type CliEntryCommandExecutionResult = Readonly<{
+    status: 'applied';
+    applied: readonly SiteCommandExecutionSuccess[];
+}> | Readonly<{
+    status: 'failed';
+    applied: readonly SiteCommandExecutionSuccess[];
+    failed: CliEntryCommandExecutionError;
+}>;
+export type CliEntryCommandSyncInput = Readonly<{
+    client: Pick<ManagementClient, 'entries'>;
+    plan: EntrySiteCommandPlan;
+    reportSubjectsByCommandRef: EntryCommandReportSubjectsByRef;
+    onBeforeExecute?: (commandCount: number) => void;
+}>;
+export type EntrySiteCommandType = 'upsertContentEntry' | 'publishContentEntry' | 'unpublishContentEntry' | 'deleteContentEntry';
+export type EntrySiteCommand = SiteCommandOf<EntrySiteCommandType>;
+export type PlannedEntrySiteCommand = {
+    [TType in EntrySiteCommandType]: PlannedSiteCommandFor<TType>;
+}[EntrySiteCommandType];
+export type EntrySiteCommandPlan = Omit<SiteCommandPlan, 'commands'> & Readonly<{
+    commands: readonly PlannedEntrySiteCommand[];
+}>;
+export declare const entrySiteCommandTypes: readonly ["upsertContentEntry", "publishContentEntry", "unpublishContentEntry", "deleteContentEntry"];
+export type EntryCommandLegacyCounter = 'created' | 'updated' | 'deleted' | 'published' | 'unpublished';
+export type EntryCommandReportSubject = Readonly<{
+    commandRef: SiteCommandRef;
+    contentType: string;
+    identifier: string;
+    counter: EntryCommandLegacyCounter;
+}>;
+export type EntryCommandReportSubjectsByRef = ReadonlyMap<SiteCommandRef, EntryCommandReportSubject>;
+export declare function compileEntryPushCommands(input: CliEntryCommandCompileInput): Result<CliEntryCommandCompileSuccess, CliCommandCompileError>;
+/** SDK push only distinguishes local development and remote production targets today. */
+export declare function runtimeForCliTarget(targetEnv: EnvTarget): AllowedRuntime;
+export declare function createCliCommandBatchRef(input: Pick<CliEntryCommandCompileInput, 'source' | 'siteId' | 'targetEnv'>): string;
+export declare function formatSiteCommandValidationErrors(errors: readonly SiteCommandValidationError[]): string;
+export declare function executeEntryCommandPlan(input: Readonly<{
+    client: Pick<ManagementClient, 'entries'>;
+    plan: Pick<EntrySiteCommandPlan, 'commands'>;
+}>): Promise<CliEntryCommandExecutionResult>;
+export declare function executeEntryCommandPlanAsSyncResult(input: CliEntryCommandSyncInput): Promise<SyncResult>;
+export declare function syncResultForEntryCommandCompileError(error: CliCommandCompileError): SyncResult;
+export declare function entryCommandExecutionToSyncResult(input: Readonly<{
+    execution: CliEntryCommandExecutionResult;
+    plan: Pick<EntrySiteCommandPlan, 'commands'>;
+    reportSubjectsByCommandRef: EntryCommandReportSubjectsByRef;
+}>): SyncResult;
+export declare function titleFromEntryData(data: Record<string, unknown>): string | undefined;

package/dist/_dts/sdk/src/cli/site-commands/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entryCommands';
+export * from './pushExecution';

package/dist/_dts/sdk/src/cli/site-commands/pushExecution.d.ts

@@ -0,0 +1,30 @@
+import { compileEntryPushCommands } from './entryCommands';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { OutputContext } from '../output';
+import { executeSyncPlan, type ContentDiff, type SyncResult } from '../sync';
+export type PushContentExecutionMode = Readonly<{
+    kind: 'entry-command';
+    compileResult: ReturnType<typeof compileEntryPushCommands>;
+}> | Readonly<{
+    kind: 'legacy-sync';
+}>;
+export declare function pushContentExecutionMode(input: Readonly<{
+    pushScope: string;
+    siteId: string;
+    target: EnvTarget;
+    diff: ContentDiff;
+    local: LocalContent;
+}>): PushContentExecutionMode;
+export declare function executeContentPushPlan(input: Readonly<{
+    pushScope: string;
+    siteId: string;
+    target: EnvTarget;
+    diff: ContentDiff;
+    local: LocalContent;
+    client: ManagementClient;
+    blockFieldExtensions: Parameters<typeof executeSyncPlan>[3]['blockFieldExtensions'];
+    output: OutputContext;
+    onEntryCommandCount?: (commandCount: number) => void;
+}>): Promise<SyncResult>;

package/dist/_dts/sdk/src/cli/sync/executor.d.ts

@@ -66,6 +66,7 @@ export interface SyncResult {
     }>;
     warnings: string[];
 }
+export declare function createEmptySyncResult(): SyncResult;
 export interface FooterSyncResult {
     diff: FooterDiff | null;
     synced: boolean;

package/dist/_dts/sdk/src/cli/sync/index.d.ts

@@ -4,5 +4,5 @@
  * Provides content synchronization between local files and CMS.
  */
 export { calculateDiff, calculatePullDiff, hasPendingChanges, formatDiffSummary, formatDiffDetail, buildJsonDiff, type ContentDiff, type EntryDiff, type PageDiff, type BlockDiff, type NavigationDiff, type DiffType, type DiffOptions, type JsonDiff, type JsonDiffMode, type JsonDiffChange, type JsonDiffChangeType, type JsonDiffOperation, type PullJsonDiff, type PullJsonDiffChange, type FieldChange, findChangedFieldsWithValues, formatValue, formatHumanDiff, } from './diff';
-export { executeSyncPlan, formatSyncResult, syncFooter, type SyncOptions, type SyncResult, type FooterSyncResult, } from './executor';
+export { executeSyncPlan, createEmptySyncResult, formatSyncResult, syncFooter, type SyncOptions, type SyncResult, type FooterSyncResult, } from './executor';
 export { extractMediaPaths, buildStorageUrl, downloadMedia, syncMedia, type MediaSyncResult, type MediaSyncSummary, type MediaSyncOptions, type MediaUploadClient, } from './media';

package/dist/_dts/sdk/src/public-api/contracts.d.ts

@@ -283,14 +283,17 @@ export type SiteResponse = {
     theme: Theme;
     themeId?: string | null;
     selectionId?: string | null;
+    selectionUpdatedAt?: string | null;
     /**
-     * Persisted Style configurator selections (Phase C). Optional so legacy
+     * Persisted design selections. Optional so legacy
      * payloads without these columns still satisfy the type — consumers fall
      * back to the site style's defaults when null.
      */
     selectionButtonPersonalityId?: string | null;
     selectionPaletteVariantId?: string | null;
     selectionPaletteOverrides?: Record<string, string> | null;
+    selectionHeaderLookId?: string | null;
+    selectionFooterLookId?: string | null;
     navigation: NavigationMenuWithItems[];
     appointmentsEnabled?: boolean;
     portalEnabled?: boolean;

package/dist/_dts/sdk/src/version.d.ts

@@ -8,4 +8,4 @@
  * 1. This constant
  * 2. The "version" field in package.json
  */
-export declare const SDK_VERSION = "0.62.2";
+export declare const SDK_VERSION = "0.64.0";