@riverbankcms/sdk 0.62.4 → 0.67.0

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

@@ -0,0 +1,114 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { type DryRunReport, type SiteCommandBatch, type SiteCommandExecutionSuccess, type SiteCommandOf, type SiteCommandPlanFor, type SiteCommandRef, type SiteCommandType, type SiteCommandValidationError } from '@riverbankcms/site-commands';
+import type { EnvTarget } from '../helpers';
+import { type SyncResult } from '../sync';
+export type CliCommandBatchRefInput<TSource extends string = string> = Readonly<{
+    source: TSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+}>;
+export type CliCommandExecutionError<TCommandType extends SiteCommandType> = Readonly<{
+    code: 'management_api_failed';
+    commandRef: SiteCommandRef;
+    commandType: TCommandType;
+    message: string;
+}>;
+export type CliCommandExecutionResult<TCommandType extends SiteCommandType> = Readonly<{
+    status: 'applied';
+    applied: readonly SiteCommandExecutionSuccess[];
+}> | Readonly<{
+    status: 'failed';
+    applied: readonly SiteCommandExecutionSuccess[];
+    failed: CliCommandExecutionError<TCommandType>;
+}>;
+export type PlannedCliCommand<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: SiteCommandType;
+}>> = Readonly<{
+    command: TCommand;
+}>;
+export type CliCommandReportBinding<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: SiteCommandType;
+}>, TSubject> = Readonly<{
+    command: TCommand;
+    reportSubject: TSubject;
+}>;
+export type CliCommandReportedPlannedCommand<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: SiteCommandType;
+}>, TSubject> = Readonly<{
+    plannedCommand: PlannedCliCommand<TCommand>;
+    reportSubject: TSubject;
+}>;
+export type CliCommandExecutionReportFailure<TSubject> = Readonly<{
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+}>;
+export type CliCommandExecutionReport<TSubject> = Readonly<{
+    appliedSubjects: readonly TSubject[];
+    failure: CliCommandExecutionReportFailure<TSubject> | null;
+    warnings: readonly string[];
+}>;
+export type CliCommandValidationCompileError = Readonly<{
+    code: 'command_validation_failed';
+    errors: readonly SiteCommandValidationError[];
+    message: string;
+}>;
+export type CliCommandCompileBatchSuccess<TCommandType extends SiteCommandType> = Readonly<{
+    batch: SiteCommandBatch;
+    plan: SiteCommandPlanFor<TCommandType>;
+    dryRunReport: DryRunReport;
+}>;
+export type CliCommandCompileBatchSuccessWithReports<TCommandType extends SiteCommandType, TSubject> = Readonly<{
+    reportedCommands: readonly CliCommandReportedPlannedCommand<SiteCommandOf<TCommandType>, TSubject>[];
+}> & CliCommandCompileBatchSuccess<TCommandType>;
+export declare function createCliCommandBatchRef(input: CliCommandBatchRefInput): string;
+export declare function formatSiteCommandValidationErrors(errors: readonly {
+    message: string;
+}[]): string;
+export declare function formatManagementError(error: unknown): string;
+export declare function planCliCommandBatchForTypes<TCommandType extends SiteCommandType>(input: CliCommandBatchRefInput & Readonly<{
+    commands: readonly SiteCommandOf<TCommandType>[];
+    commandTypes: readonly TCommandType[];
+}>): Result<CliCommandCompileBatchSuccess<TCommandType>, CliCommandValidationCompileError>;
+export declare function planCliCommandBatchForBindings<TCommandType extends SiteCommandType, TSubject>(input: CliCommandBatchRefInput & Readonly<{
+    commandBindings: readonly CliCommandReportBinding<SiteCommandOf<TCommandType>, TSubject>[];
+    commandTypes: readonly TCommandType[];
+}>): Result<CliCommandCompileBatchSuccessWithReports<TCommandType, TSubject>, CliCommandValidationCompileError>;
+export declare function executeCliCommandPlan<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: TCommandType;
+}>, TCommandType extends SiteCommandType>(input: Readonly<{
+    commands: readonly PlannedCliCommand<TCommand>[];
+    applyCommand: (command: TCommand) => Promise<void>;
+}>): Promise<CliCommandExecutionResult<TCommandType>>;
+export declare function commandExecutionToReport<TCommand extends Readonly<{
+    ref: SiteCommandRef;
+    type: TCommandType;
+}>, TCommandType extends SiteCommandType, TSubject>(input: Readonly<{
+    execution: CliCommandExecutionResult<TCommandType>;
+    reportedCommands: readonly CliCommandReportedPlannedCommand<TCommand, TSubject>[];
+    resourceLabel: string;
+    commandDisplayIdentifier: (command: TCommand) => string;
+    includeFailureSubject?: boolean;
+}>): CliCommandExecutionReport<TSubject>;
+export declare function commandReportToSyncResult<TSubject>(input: Readonly<{
+    report: CliCommandExecutionReport<TSubject>;
+    incrementSuccess: (result: SyncResult, subject: TSubject) => void;
+    recordFailure: (result: SyncResult, identifier: string, message: string, subject: TSubject | undefined) => void;
+}>): SyncResult;
+export declare function executeCompiledCliCommandPlanAsSyncResult<TCompiledPlan extends Readonly<{
+    plan: Readonly<{
+        commands: readonly unknown[];
+    }>;
+}>, TExecutionResult>(input: Readonly<{
+    compiledPlan: TCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+    executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
+    executionToSyncResult: (input: Readonly<{
+        execution: TExecutionResult;
+        compiledPlan: TCompiledPlan;
+    }>) => SyncResult;
+}>): Promise<SyncResult>;

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

@@ -0,0 +1,63 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { type AllowedRuntime, type SiteCommandOf } 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';
+import { type CliContentTypeKey, type CliEntryIdentifier } from './commandKeys';
+import { type CliCommandCompileBatchSuccessWithReports, type CliCommandValidationCompileError, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult } from './commandRuntime';
+export type CliEntryCommandBatchSource = 'push_entries' | 'merge_remote_entries';
+export type CliCommandCompileError = Readonly<{
+    code: 'missing_local_entry';
+    contentType: CliContentTypeKey;
+    identifier: CliEntryIdentifier;
+    message: string;
+}> | CliCommandValidationCompileError;
+export type CliEntryCommandCompileInput = Readonly<{
+    source: CliEntryCommandBatchSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+    diff: Pick<ContentDiff, 'entries'>;
+    local: Pick<LocalContent, 'entries'>;
+}>;
+export type CliEntryCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<EntrySiteCommandType, EntryCommandReportSubject>;
+export type CliEntryCommandExecutionError = CliCommandExecutionError<EntrySiteCommandType>;
+export type CliEntryCommandExecutionResult = CliCommandExecutionResult<EntrySiteCommandType>;
+export type CliEntryCommandSyncInput = Readonly<{
+    client: Pick<ManagementClient, 'entries'>;
+    compiledPlan: EntryCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>;
+export type EntrySiteCommandType = 'upsertContentEntry' | 'publishContentEntry' | 'unpublishContentEntry' | 'deleteContentEntry';
+export type EntrySiteCommand = SiteCommandOf<EntrySiteCommandType>;
+export type EntrySiteCommandPlan = CliEntryCommandCompileSuccess['plan'];
+export declare const entrySiteCommandTypes: readonly ["upsertContentEntry", "publishContentEntry", "unpublishContentEntry", "deleteContentEntry"];
+export type EntryCommandSyncCounter = 'created' | 'updated' | 'deleted' | 'published' | 'unpublished';
+export type EntryCommandReportSubject = Readonly<{
+    contentType: CliContentTypeKey;
+    identifier: CliEntryIdentifier;
+    counter: EntryCommandSyncCounter;
+}>;
+export type EntryCommandExecutionReport = CliCommandExecutionReport<EntryCommandReportSubject>;
+type EntryCommandCompiledPlan = Pick<CliEntryCommandCompileSuccess, 'plan' | 'reportedCommands'>;
+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 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;
+    compiledPlan: EntryCommandCompiledPlan;
+}>): SyncResult;
+export declare function entryCommandExecutionToReport(input: Readonly<{
+    execution: CliEntryCommandExecutionResult;
+    compiledPlan: EntryCommandCompiledPlan;
+}>): EntryCommandExecutionReport;
+export declare function entryCommandReportToSyncResult(report: EntryCommandExecutionReport): SyncResult;
+export declare function titleFromEntryData(data: Record<string, unknown>): string | undefined;
+export {};

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

@@ -0,0 +1,50 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { type SiteCommandOf } from '@riverbankcms/site-commands';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalFooterContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { FooterDiff } from '../sync/diff';
+import { type SyncResult } from '../sync';
+import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
+export type CliFooterCommandBatchSource = 'push_footer';
+export type CliFooterCommandCompileError = CliCommandValidationCompileError;
+export type CliFooterCommandCompileInput = Readonly<{
+    source: CliFooterCommandBatchSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+    diff: FooterDiff;
+    local: LocalFooterContent;
+}>;
+export type CliFooterCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<FooterSiteCommandType, FooterCommandReportSubject>;
+export type FooterSiteCommandType = 'upsertFooterContent';
+export type FooterSiteCommand = SiteCommandOf<FooterSiteCommandType>;
+export type FooterSiteCommandPlan = CliFooterCommandCompileSuccess['plan'];
+export type CliFooterCommandExecutionError = CliCommandExecutionError<FooterSiteCommandType>;
+export type CliFooterCommandExecutionResult = CliCommandExecutionResult<FooterSiteCommandType>;
+export declare const footerSiteCommandTypes: readonly ["upsertFooterContent"];
+export type FooterCommandReportSubject = Readonly<{
+    identifier: 'footer';
+}>;
+export type FooterCommandExecutionReport = CliCommandExecutionReport<FooterCommandReportSubject>;
+type FooterCommandCompiledPlan = Pick<CliFooterCommandCompileSuccess, 'plan' | 'reportedCommands'>;
+export declare function compileFooterPushCommands(input: CliFooterCommandCompileInput): Result<CliFooterCommandCompileSuccess, CliFooterCommandCompileError>;
+export declare function executeFooterCommandPlan(input: Readonly<{
+    client: Pick<ManagementClient, 'footer'>;
+    plan: Pick<FooterSiteCommandPlan, 'commands'>;
+}>): Promise<CliFooterCommandExecutionResult>;
+export declare function executeFooterCommandPlanAsSyncResult(input: Readonly<{
+    client: Pick<ManagementClient, 'footer'>;
+    compiledPlan: FooterCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<SyncResult>;
+export declare function syncResultForFooterCommandCompileError(error: CliFooterCommandCompileError): SyncResult;
+export declare function footerCommandExecutionToSyncResult(input: Readonly<{
+    execution: CliFooterCommandExecutionResult;
+    compiledPlan: FooterCommandCompiledPlan;
+}>): SyncResult;
+export declare function footerCommandExecutionToReport(input: Readonly<{
+    execution: CliFooterCommandExecutionResult;
+    compiledPlan: FooterCommandCompiledPlan;
+}>): FooterCommandExecutionReport;
+export declare function footerCommandReportToSyncResult(report: FooterCommandExecutionReport): SyncResult;
+export {};

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

@@ -0,0 +1,57 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { type SiteCommandOf } 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';
+import { type CliFormSlug } from './commandKeys';
+import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
+export type CliFormCommandBatchSource = 'push_forms';
+export type CliFormCommandCompileError = Readonly<{
+    code: 'missing_local_form';
+    slug: CliFormSlug;
+    message: string;
+}> | CliCommandValidationCompileError;
+export type CliFormCommandCompileInput = Readonly<{
+    source: CliFormCommandBatchSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+    diff: Pick<ContentDiff, 'forms'>;
+    local: Pick<LocalContent, 'forms'>;
+}>;
+export type CliFormCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<FormSiteCommandType, FormCommandReportSubject>;
+export type FormSiteCommandType = 'upsertForm';
+export type FormSiteCommand = SiteCommandOf<FormSiteCommandType>;
+export type FormSiteCommandPlan = CliFormCommandCompileSuccess['plan'];
+export type CliFormCommandExecutionError = CliCommandExecutionError<FormSiteCommandType>;
+export type CliFormCommandExecutionResult = CliCommandExecutionResult<FormSiteCommandType>;
+export declare const formSiteCommandTypes: readonly ["upsertForm"];
+export type FormCommandSyncCounter = 'created' | 'updated';
+export type FormCommandReportSubject = Readonly<{
+    slug: CliFormSlug;
+    counter: FormCommandSyncCounter;
+}>;
+export type FormCommandExecutionReport = CliCommandExecutionReport<FormCommandReportSubject>;
+type FormCommandCompiledPlan = Pick<CliFormCommandCompileSuccess, 'plan' | 'reportedCommands'>;
+export declare function compileFormPushCommands(input: CliFormCommandCompileInput): Result<CliFormCommandCompileSuccess, CliFormCommandCompileError>;
+export declare function executeFormCommandPlan(input: Readonly<{
+    client: Pick<ManagementClient, 'forms'>;
+    plan: Pick<FormSiteCommandPlan, 'commands'>;
+}>): Promise<CliFormCommandExecutionResult>;
+export declare function executeFormCommandPlanAsSyncResult(input: Readonly<{
+    client: Pick<ManagementClient, 'forms'>;
+    compiledPlan: FormCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<SyncResult>;
+export declare function syncResultForFormCommandCompileError(error: CliFormCommandCompileError): SyncResult;
+export declare function formCommandExecutionToSyncResult(input: Readonly<{
+    execution: CliFormCommandExecutionResult;
+    compiledPlan: FormCommandCompiledPlan;
+}>): SyncResult;
+export declare function formCommandExecutionToReport(input: Readonly<{
+    execution: CliFormCommandExecutionResult;
+    compiledPlan: FormCommandCompiledPlan;
+}>): FormCommandExecutionReport;
+export declare function formCommandReportToSyncResult(report: FormCommandExecutionReport): SyncResult;
+export {};

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

@@ -0,0 +1,7 @@
+export * from './commandRuntime';
+export * from './entryCommands';
+export * from './formCommands';
+export * from './footerCommands';
+export * from './navigationCommands';
+export * from './pageCommands';
+export * from './pushExecution';

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

@@ -0,0 +1,57 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { type SiteCommandOf } from '@riverbankcms/site-commands';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { NavigationDiff } from '../sync/diff';
+import { type SyncResult } from '../sync';
+import { type CliNavigationMenuName } from './commandKeys';
+import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
+export type CliNavigationCommandBatchSource = 'push_navigation';
+export type CliNavigationCommandCompileError = Readonly<{
+    code: 'missing_local_navigation_menu';
+    name: CliNavigationMenuName;
+    message: string;
+}> | CliCommandValidationCompileError;
+export type CliNavigationCommandCompileInput = Readonly<{
+    source: CliNavigationCommandBatchSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+    diff: readonly NavigationDiff[];
+    local: Pick<LocalContent, 'navigation'>;
+}>;
+export type CliNavigationCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<NavigationSiteCommandType, NavigationCommandReportSubject>;
+export type CliNavigationCommandExecutionError = CliCommandExecutionError<NavigationSiteCommandType>;
+export type CliNavigationCommandExecutionResult = CliCommandExecutionResult<NavigationSiteCommandType>;
+export type NavigationSiteCommandType = 'upsertNavigationMenu';
+export type NavigationSiteCommand = SiteCommandOf<NavigationSiteCommandType>;
+export type NavigationSiteCommandPlan = CliNavigationCommandCompileSuccess['plan'];
+export declare const navigationSiteCommandTypes: readonly ["upsertNavigationMenu"];
+export type NavigationCommandSyncCounter = 'created' | 'updated';
+export type NavigationCommandReportSubject = Readonly<{
+    name: CliNavigationMenuName;
+    counter: NavigationCommandSyncCounter;
+}>;
+export type NavigationCommandExecutionReport = CliCommandExecutionReport<NavigationCommandReportSubject>;
+type NavigationCommandCompiledPlan = Pick<CliNavigationCommandCompileSuccess, 'plan' | 'reportedCommands'>;
+export declare function compileNavigationPushCommands(input: CliNavigationCommandCompileInput): Result<CliNavigationCommandCompileSuccess, CliNavigationCommandCompileError>;
+export declare function executeNavigationCommandPlan(input: Readonly<{
+    client: Pick<ManagementClient, 'navigation'>;
+    plan: Pick<NavigationSiteCommandPlan, 'commands'>;
+}>): Promise<CliNavigationCommandExecutionResult>;
+export declare function executeNavigationCommandPlanAsSyncResult(input: Readonly<{
+    client: Pick<ManagementClient, 'navigation'>;
+    compiledPlan: NavigationCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<SyncResult>;
+export declare function syncResultForNavigationCommandCompileError(error: CliNavigationCommandCompileError): SyncResult;
+export declare function navigationCommandExecutionToSyncResult(input: Readonly<{
+    execution: CliNavigationCommandExecutionResult;
+    compiledPlan: NavigationCommandCompiledPlan;
+}>): SyncResult;
+export declare function navigationCommandExecutionToReport(input: Readonly<{
+    execution: CliNavigationCommandExecutionResult;
+    compiledPlan: NavigationCommandCompiledPlan;
+}>): NavigationCommandExecutionReport;
+export declare function navigationCommandReportToSyncResult(report: NavigationCommandExecutionReport): SyncResult;
+export {};

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

@@ -0,0 +1,83 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { type SiteCommandOf } from '@riverbankcms/site-commands';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { BlockFieldExtensionsMap } from '../../config/types';
+import type { ContentDiff } from '../sync/diff';
+import { type SyncResult } from '../sync';
+import { type CliBlockIdentifier, type CliPageIdentifier } from './commandKeys';
+import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
+export type CliPageCommandBatchSource = 'push_pages';
+export type CliPageCommandCompileError = Readonly<{
+    code: 'missing_local_page';
+    identifier: CliPageIdentifier;
+    message: string;
+}> | Readonly<{
+    code: 'missing_local_block';
+    identifier: `${CliPageIdentifier}/${CliBlockIdentifier}`;
+    message: string;
+}> | Readonly<{
+    code: 'invalid_page_block';
+    identifier: `${CliPageIdentifier}/${CliBlockIdentifier}`;
+    warnings: readonly string[];
+    message: string;
+}> | CliCommandValidationCompileError;
+export type CliPageCommandCompileInput = Readonly<{
+    source: CliPageCommandBatchSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+    diff: Pick<ContentDiff, 'pages'>;
+    local: Pick<LocalContent, 'pages'>;
+    blockFieldExtensions?: BlockFieldExtensionsMap;
+}>;
+export type CliPageCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<PageSiteCommandType, PageCommandReportSubject> & Readonly<{
+    warnings: readonly string[];
+}>;
+export type PageSiteCommandType = 'upsertPage' | 'upsertPageBlock' | 'deletePageBlock' | 'reorderPageBlocks' | 'publishPage' | 'unpublishPage';
+export type PageSiteCommand = SiteCommandOf<PageSiteCommandType>;
+export type PageSiteCommandPlan = CliPageCommandCompileSuccess['plan'];
+export type CliPageCommandExecutionError = CliCommandExecutionError<PageSiteCommandType>;
+export type CliPageCommandExecutionResult = CliCommandExecutionResult<PageSiteCommandType>;
+export declare const pageSiteCommandTypes: readonly ["upsertPage", "upsertPageBlock", "deletePageBlock", "reorderPageBlocks", "publishPage", "unpublishPage"];
+export type PageCommandSyncCounter = 'created' | 'updated' | 'published' | 'unpublished';
+export type BlockCommandSyncCounter = 'created' | 'updated' | 'deleted' | 'reordered';
+export type PageCommandReportSubject = Readonly<{
+    resource: 'page';
+    identifier: CliPageIdentifier;
+    counter: PageCommandSyncCounter;
+}> | Readonly<{
+    resource: 'block';
+    pageIdentifier: CliPageIdentifier;
+    identifier: CliBlockIdentifier | CliPageIdentifier;
+    counter: BlockCommandSyncCounter;
+}>;
+export type PageCommandExecutionReport = CliCommandExecutionReport<PageCommandReportSubject>;
+type PageCommandCompiledPlan = Pick<CliPageCommandCompileSuccess, 'plan' | 'reportedCommands' | 'warnings'>;
+export declare function compilePagePushCommands(input: CliPageCommandCompileInput): Result<CliPageCommandCompileSuccess, CliPageCommandCompileError>;
+export type PageCommandRoutingDecision = Readonly<{
+    kind: 'no_page_changes';
+}> | Readonly<{
+    kind: 'command_backed';
+}>;
+export declare function pageCommandRouting(diff: Pick<ContentDiff, 'pages'>): PageCommandRoutingDecision;
+export declare function executePageCommandPlan(input: Readonly<{
+    client: Pick<ManagementClient, 'pages' | 'blocks'>;
+    plan: Pick<PageSiteCommandPlan, 'commands'>;
+}>): Promise<CliPageCommandExecutionResult>;
+export declare function executePageCommandPlanAsSyncResult(input: Readonly<{
+    client: Pick<ManagementClient, 'pages' | 'blocks'>;
+    compiledPlan: PageCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<SyncResult>;
+export declare function syncResultForPageCommandCompileError(error: CliPageCommandCompileError): SyncResult;
+export declare function pageCommandExecutionToSyncResult(input: Readonly<{
+    execution: CliPageCommandExecutionResult;
+    compiledPlan: PageCommandCompiledPlan;
+}>): SyncResult;
+export declare function pageCommandExecutionToReport(input: Readonly<{
+    execution: CliPageCommandExecutionResult;
+    compiledPlan: PageCommandCompiledPlan;
+}>): PageCommandExecutionReport;
+export declare function pageCommandReportToSyncResult(report: PageCommandExecutionReport): SyncResult;
+export {};

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

@@ -0,0 +1,83 @@
+import { type Result, type SiteId } from '@riverbankcms/core';
+import { compileEntryPushCommands } from './entryCommands';
+import { compileFormPushCommands } from './formCommands';
+import { compileNavigationPushCommands } from './navigationCommands';
+import { compilePagePushCommands } from './pageCommands';
+import type { ManagementClient } from '../../client/management/types';
+import type { PushScope } from '../commands/push/consts';
+import type { LocalContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { OutputContext } from '../output';
+import { type ContentDiff, type ResidualSettingsDiff, type ResidualSettingsLocalContent, type SyncResult } from '../sync';
+export type CommandSurface = 'entry' | 'page' | 'form' | 'navigation';
+type ResidualSettingsPushPlan = Readonly<{
+    diff: ResidualSettingsDiff;
+    local: ResidualSettingsLocalContent;
+}>;
+type CommandSurfaceFailurePolicy = 'continue' | 'stop';
+export type CommandSurfaceCompileResult = Readonly<{
+    surface: 'entry';
+    compileResult: ReturnType<typeof compileEntryPushCommands>;
+}> | Readonly<{
+    surface: 'page';
+    compileResult: ReturnType<typeof compilePagePushCommands>;
+}> | Readonly<{
+    surface: 'form';
+    compileResult: ReturnType<typeof compileFormPushCommands>;
+}> | Readonly<{
+    surface: 'navigation';
+    compileResult: ReturnType<typeof compileNavigationPushCommands>;
+}>;
+export type CommandSurfaceCompileSuccess = Readonly<{
+    surface: 'entry';
+    compileValue: OkValue<ReturnType<typeof compileEntryPushCommands>>;
+}> | Readonly<{
+    surface: 'page';
+    compileValue: OkValue<ReturnType<typeof compilePagePushCommands>>;
+}> | Readonly<{
+    surface: 'form';
+    compileValue: OkValue<ReturnType<typeof compileFormPushCommands>>;
+}> | Readonly<{
+    surface: 'navigation';
+    compileValue: OkValue<ReturnType<typeof compileNavigationPushCommands>>;
+}>;
+type OkValue<T> = T extends Readonly<{
+    ok: true;
+    value: infer TValue;
+}> ? TValue : never;
+export type ContentPushExecutionStep = Readonly<{
+    kind: 'residual-settings-sync';
+    residual: ResidualSettingsPushPlan;
+    onFailure: CommandSurfaceFailurePolicy;
+}> | Readonly<{
+    kind: 'command-surface';
+    surface: CommandSurfaceCompileSuccess;
+    onFailure: CommandSurfaceFailurePolicy;
+}>;
+export type ContentPushExecutionPlan = Readonly<{
+    kind: 'sync-steps';
+    steps: readonly ContentPushExecutionStep[];
+}>;
+export declare function executeContentPushPlan(input: Readonly<{
+    pushScope: PushScope;
+    siteId: SiteId;
+    target: EnvTarget;
+    diff: ContentDiff;
+    local: LocalContent;
+    client: ManagementClient;
+    blockFieldExtensions: Parameters<typeof compilePagePushCommands>[0]['blockFieldExtensions'];
+    output: OutputContext;
+    onEntryCommandCount?: (commandCount: number) => void;
+    onFormCommandCount?: (commandCount: number) => void;
+    onNavigationCommandCount?: (commandCount: number) => void;
+    onPageCommandCount?: (commandCount: number) => void;
+}>): Promise<SyncResult>;
+export declare function planContentPushExecution(input: Readonly<{
+    pushScope: PushScope;
+    siteId: SiteId;
+    target: EnvTarget;
+    diff: ContentDiff;
+    local: LocalContent;
+    blockFieldExtensions?: Parameters<typeof compilePagePushCommands>[0]['blockFieldExtensions'];
+}>): Result<ContentPushExecutionPlan, SyncResult>;
+export {};

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

@@ -1,14 +1,14 @@
 /**
- * Sync Executor
+ * Residual Sync Executor
  *
- * Applies content changes to the CMS based on a calculated diff.
- * Supports dry-run mode and progress reporting.
+ * Applies the small set of SDK CLI writes that have not yet moved onto the
+ * shared site-command IR. Command-backed surfaces fail closed here so direct
+ * writes cannot silently come back through this path.
  */
 import type { ManagementClient } from '../../client/management/types';
-import type { LocalContent, LocalFooterContent } from '../content/reader';
+import type { LocalContent } from '../content/reader';
 import type { OutputContext } from '../output';
-import type { ContentDiff, FooterDiff } from './diff';
-import type { BlockFieldExtensionsMap } from '../../config/types';
+import type { ContentDiff } from './diff';
 /**
  * Format API errors with detailed field validation info when available.
  */
@@ -16,8 +16,6 @@ export declare function formatApiError(error: unknown): string;
 export interface SyncOptions {
     /** If true, don't actually make changes */
     dryRun: boolean;
-    /** Custom block field extensions from config (for validation) */
-    blockFieldExtensions?: BlockFieldExtensionsMap;
 }
 export interface SyncResult {
     entries: {
@@ -66,26 +64,11 @@ export interface SyncResult {
     }>;
     warnings: string[];
 }
-export interface FooterSyncResult {
-    diff: FooterDiff | null;
-    synced: boolean;
-    error?: string;
-}
-/**
- * Sync footer content from local to CMS.
- *
- * Footer is synced separately from other content because:
- * - It's a single entity (not a collection)
- * - It requires pulling remote state first for comparison
- *
- * @param client - Management client
- * @param localFooter - Local footer content from footer.json
- * @param options - Sync options (dryRun)
- * @returns Footer sync result with diff and status
- */
-export declare function syncFooter(client: ManagementClient, localFooter: LocalFooterContent, options: SyncOptions): Promise<FooterSyncResult>;
+export type ResidualSettingsDiff = Readonly<Pick<ContentDiff, 'settings' | 'summary'>>;
+export type ResidualSettingsLocalContent = Readonly<Pick<LocalContent, 'settings'>>;
+export declare function createEmptySyncResult(): SyncResult;
 /**
- * Execute a sync plan based on calculated diff.
+ * Execute the remaining settings-only sync plan.
  *
  * @param client - Management client
  * @param diff - Calculated content diff
@@ -94,7 +77,7 @@ export declare function syncFooter(client: ManagementClient, localFooter: LocalF
  * @param output - Output context for progress reporting
  * @returns Sync result with counts and errors
  */
-export declare function executeSyncPlan(client: ManagementClient, diff: ContentDiff, local: LocalContent, options: SyncOptions, output: OutputContext): Promise<SyncResult>;
+export declare function executeResidualSettingsSyncPlan(client: ManagementClient, diff: ResidualSettingsDiff, local: ResidualSettingsLocalContent, options: SyncOptions, output: OutputContext): Promise<SyncResult>;
 /**
  * Format sync result for display.
  */

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 { executeResidualSettingsSyncPlan, createEmptySyncResult, formatSyncResult, type SyncOptions, type SyncResult, type ResidualSettingsDiff, type ResidualSettingsLocalContent, } from './executor';
 export { extractMediaPaths, buildStorageUrl, downloadMedia, syncMedia, type MediaSyncResult, type MediaSyncSummary, type MediaSyncOptions, type MediaUploadClient, } from './media';