@riverbankcms/sdk 0.64.0 → 0.68.0

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

@@ -1,85 +1,65 @@
-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 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 { 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: string;
-    identifier: string;
+    contentType: CliContentTypeKey;
+    identifier: CliEntryIdentifier;
     message: string;
-}> | Readonly<{
-    code: 'command_validation_failed';
-    errors: readonly SiteCommandValidationError[];
-    message: string;
-}>;
+}> | CliCommandValidationCompileError;
 export type CliEntryCommandCompileInput = Readonly<{
     source: CliEntryCommandBatchSource;
-    siteId: string;
+    siteId: SiteId;
     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 CliEntryCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<EntrySiteCommandType, EntryCommandReportSubject>;
+export type CliEntryCommandExecutionError = CliCommandExecutionError<EntrySiteCommandType>;
+export type CliEntryCommandExecutionResult = CliCommandExecutionResult<EntrySiteCommandType>;
 export type CliEntryCommandSyncInput = Readonly<{
     client: Pick<ManagementClient, 'entries'>;
-    plan: EntrySiteCommandPlan;
-    reportSubjectsByCommandRef: EntryCommandReportSubjectsByRef;
+    compiledPlan: EntryCommandCompiledPlan;
     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 type EntrySiteCommandPlan = CliEntryCommandCompileSuccess['plan'];
 export declare const entrySiteCommandTypes: readonly ["upsertContentEntry", "publishContentEntry", "unpublishContentEntry", "deleteContentEntry"];
-export type EntryCommandLegacyCounter = 'created' | 'updated' | 'deleted' | 'published' | 'unpublished';
+export type EntryCommandSyncCounter = 'created' | 'updated' | 'deleted' | 'published' | 'unpublished';
 export type EntryCommandReportSubject = Readonly<{
-    commandRef: SiteCommandRef;
-    contentType: string;
-    identifier: string;
-    counter: EntryCommandLegacyCounter;
+    contentType: CliContentTypeKey;
+    identifier: CliEntryIdentifier;
+    counter: EntryCommandSyncCounter;
 }>;
-export type EntryCommandReportSubjectsByRef = ReadonlyMap<SiteCommandRef, EntryCommandReportSubject>;
+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 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 executeEntryCommandPlanAsReport(input: CliEntryCommandSyncInput): Promise<EntryCommandExecutionReport>;
 export declare function syncResultForEntryCommandCompileError(error: CliCommandCompileError): SyncResult;
+export declare function entryCommandCompileErrorToReport(error: CliCommandCompileError): EntryCommandExecutionReport;
 export declare function entryCommandExecutionToSyncResult(input: Readonly<{
     execution: CliEntryCommandExecutionResult;
-    plan: Pick<EntrySiteCommandPlan, 'commands'>;
-    reportSubjectsByCommandRef: EntryCommandReportSubjectsByRef;
+    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,56 @@
+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 executeFooterCommandPlanAsReport(input: Readonly<{
+    client: Pick<ManagementClient, 'footer'>;
+    compiledPlan: FooterCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<FooterCommandExecutionReport>;
+export declare function syncResultForFooterCommandCompileError(error: CliFooterCommandCompileError): SyncResult;
+export declare function footerCommandCompileErrorToReport(error: CliFooterCommandCompileError): FooterCommandExecutionReport;
+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,53 @@
+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 executeFormCommandPlanAsReport(input: Readonly<{
+    client: Pick<ManagementClient, 'forms'>;
+    compiledPlan: FormCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<FormCommandExecutionReport>;
+export declare function formCommandCompileErrorToReport(error: CliFormCommandCompileError): FormCommandExecutionReport;
+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

@@ -1,2 +1,8 @@
+export * from './commandRuntime';
+export * from './datedOfferingCommands';
 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,53 @@
+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 executeNavigationCommandPlanAsReport(input: Readonly<{
+    client: Pick<ManagementClient, 'navigation'>;
+    compiledPlan: NavigationCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<NavigationCommandExecutionReport>;
+export declare function navigationCommandCompileErrorToReport(error: CliNavigationCommandCompileError): NavigationCommandExecutionReport;
+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,79 @@
+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 executePageCommandPlanAsReport(input: Readonly<{
+    client: Pick<ManagementClient, 'pages' | 'blocks'>;
+    compiledPlan: PageCommandCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+}>): Promise<PageCommandExecutionReport>;
+export declare function pageCommandCompileErrorToReport(error: CliPageCommandCompileError): PageCommandExecutionReport;
+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

@@ -1,30 +1,29 @@
-import { compileEntryPushCommands } from './entryCommands';
+import { type SiteId } from '@riverbankcms/core';
 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;
+import { type ContentDiff, type SyncResult } from '../sync';
+import { type CommandSurfaceDispatchDependencies } from './commandSurfaceDispatch';
+import { planContentPushExecution } from './pushExecutionPlan';
+import type { CommandSurface, CommandSurfaceCompileResult, CommandSurfaceCompileSuccess, CommandSurfaceExecutionReport, ContentPushScope, ContentPushExecutionPlan, ContentPushExecutionReport, ContentPushExecutionStep } from './pushExecutionTypes';
+import type { compilePagePushCommands } from './pageCommands';
+export { planContentPushExecution };
+export type { CommandSurface, CommandSurfaceCompileResult, CommandSurfaceCompileSuccess, CommandSurfaceExecutionReport, ContentPushScope, ContentPushExecutionPlan, ContentPushExecutionReport, ContentPushExecutionStep, };
+export type ContentPushExecutionInput = Readonly<{
+    pushScope: ContentPushScope;
+    siteId: SiteId;
     target: EnvTarget;
     diff: ContentDiff;
     local: LocalContent;
     client: ManagementClient;
-    blockFieldExtensions: Parameters<typeof executeSyncPlan>[3]['blockFieldExtensions'];
+    blockFieldExtensions: Parameters<typeof compilePagePushCommands>[0]['blockFieldExtensions'];
     output: OutputContext;
     onEntryCommandCount?: (commandCount: number) => void;
-}>): Promise<SyncResult>;
+    onFormCommandCount?: (commandCount: number) => void;
+    onNavigationCommandCount?: (commandCount: number) => void;
+    onPageCommandCount?: (commandCount: number) => void;
+}>;
+export declare function executeContentPushPlan(input: ContentPushExecutionInput): Promise<SyncResult>;
+export declare function executeContentPushPlanAsCommandReport(input: ContentPushExecutionInput, dependencies?: CommandSurfaceDispatchDependencies): Promise<ContentPushExecutionReport>;
+export declare function contentPushExecutionReportToSyncResult(report: ContentPushExecutionReport): SyncResult;

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

@@ -0,0 +1,8 @@
+import type { LocalContent } from '../content/reader';
+import type { ContentDiff } from '../sync';
+import type { ContentPushScope, ContentPushExecutionPlan } from './pushExecutionTypes';
+export declare function planContentPushExecution(input: Readonly<{
+    pushScope: ContentPushScope;
+    diff: ContentDiff;
+    local: LocalContent;
+}>): ContentPushExecutionPlan;

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

@@ -0,0 +1,97 @@
+import type { SiteCommandRef, SiteCommandType } from '@riverbankcms/site-commands';
+import type { SyncResult, ResidualSettingsDiff, ResidualSettingsLocalContent } from '../sync';
+import type { PushScope } from '../commands/push/consts';
+import type { compileEntryPushCommands, EntryCommandExecutionReport } from './entryCommands';
+import type { compileFormPushCommands, FormCommandExecutionReport } from './formCommands';
+import type { compileNavigationPushCommands, NavigationCommandExecutionReport } from './navigationCommands';
+import type { compilePagePushCommands, PageCommandExecutionReport } from './pageCommands';
+export type CommandSurface = 'entry' | 'page' | 'form' | 'navigation';
+export type CommandSurfaceFailurePolicy = 'continue' | 'stop';
+export type ContentPushScope = Extract<PushScope, 'entries' | 'pages' | 'navigation' | 'forms' | 'all'>;
+export type ResidualSettingsPushPlan = Readonly<{
+    diff: ResidualSettingsDiff;
+    local: ResidualSettingsLocalContent;
+}>;
+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: CommandSurface;
+    onFailure: CommandSurfaceFailurePolicy;
+}>;
+export type CompiledContentPushExecutionStep = 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 type CompiledContentPushExecutionPlan = Readonly<{
+    kind: 'compiled-sync-steps';
+    steps: readonly CompiledContentPushExecutionStep[];
+}>;
+export type CommandSurfaceExecutionReport = Readonly<{
+    surface: 'entry';
+    report: EntryCommandExecutionReport;
+}> | Readonly<{
+    surface: 'page';
+    report: PageCommandExecutionReport;
+}> | Readonly<{
+    surface: 'form';
+    report: FormCommandExecutionReport;
+}> | Readonly<{
+    surface: 'navigation';
+    report: NavigationCommandExecutionReport;
+}>;
+export type ContentPushExecutionReport = Readonly<{
+    commandReports: readonly CommandSurfaceExecutionReport[];
+    residualSyncResults: readonly SyncResult[];
+}>;
+export type ReportedCommandWithSubject<TSubject> = Readonly<{
+    plannedCommand: Readonly<{
+        command: Readonly<{
+            ref: SiteCommandRef;
+            type: SiteCommandType;
+        }>;
+    }>;
+    reportSubject: TSubject;
+}>;
+export {};

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

@@ -0,0 +1,15 @@
+import type { LocalContent } from '../content/reader';
+import type { ContentDiff } from '../sync';
+import type { CommandSurface, ResidualSettingsPushPlan } from './pushExecutionTypes';
+export declare const baselineResidualOmittedCommandSurfaces: readonly ["navigation"];
+export declare const baselineResidualOmittedCommandSurfaceSet: ReadonlySet<CommandSurface>;
+export declare function syncPlanResidual(input: Readonly<{
+    diff: ContentDiff;
+    local: LocalContent;
+    omitSurfaces: ReadonlySet<CommandSurface>;
+}>): ResidualSettingsPushPlan;
+export declare function residualSettingsPlan(input: Readonly<{
+    diff: ContentDiff;
+    local: LocalContent;
+    commandSurfaces: readonly CommandSurface[];
+}>): ResidualSettingsPushPlan | null;

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,27 +64,11 @@ export interface SyncResult {
     }>;
     warnings: string[];
 }
+export type ResidualSettingsDiff = Readonly<Pick<ContentDiff, 'settings' | 'summary'>>;
+export type ResidualSettingsLocalContent = Readonly<Pick<LocalContent, 'settings'>>;
 export declare function createEmptySyncResult(): SyncResult;
-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>;
 /**
- * Execute a sync plan based on calculated diff.
+ * Execute the remaining settings-only sync plan.
  *
  * @param client - Management client
  * @param diff - Calculated content diff
@@ -95,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,6 @@
  * 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, createEmptySyncResult, 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 { addCounters, mergeManySyncResults, mergeSyncResults, } from './syncResultAggregation';
 export { extractMediaPaths, buildStorageUrl, downloadMedia, syncMedia, type MediaSyncResult, type MediaSyncSummary, type MediaSyncOptions, type MediaUploadClient, } from './media';

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

@@ -0,0 +1,4 @@
+import { type SyncResult } from './executor';
+export declare function mergeManySyncResults(results: readonly SyncResult[]): SyncResult;
+export declare function mergeSyncResults(first: SyncResult, second: SyncResult): SyncResult;
+export declare function addCounters<TCounters extends Record<string, number>>(first: TCounters, second: TCounters, keys: readonly (keyof TCounters)[]): TCounters;