@riverbankcms/sdk 0.64.0 → 0.67.0

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

@@ -1,3 +1,4 @@
+import { type SiteId } from '@riverbankcms/core';
 import type { ManagementClient } from '../../client/management/types';
 import type { LocalEntry } from '../content/reader';
 import type { EnvTarget } from '../helpers';
@@ -10,7 +11,7 @@ export declare function planAndReportRemoteEntryMerge(input: Readonly<{
     client: Pick<ManagementClient, 'entries' | 'pull'>;
     contentDir: string;
     target: EnvTarget;
-    siteId: string;
+    siteId: SiteId;
     contentType?: string;
     identifier?: string;
     localEntries: ReadonlyMap<string, readonly LocalEntry[]>;

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

@@ -0,0 +1,13 @@
+import type { Brand } from '@riverbankcms/core';
+export type CliContentTypeKey = Brand<string, 'SdkCliContentTypeKey'>;
+export type CliEntryIdentifier = Brand<string, 'SdkCliEntryIdentifier'>;
+export type CliPageIdentifier = Brand<string, 'SdkCliPageIdentifier'>;
+export type CliBlockIdentifier = Brand<string, 'SdkCliBlockIdentifier'>;
+export type CliFormSlug = Brand<string, 'SdkCliFormSlug'>;
+export type CliNavigationMenuName = Brand<string, 'SdkCliNavigationMenuName'>;
+export declare const asCliContentTypeKey: (value: string) => CliContentTypeKey;
+export declare const asCliEntryIdentifier: (value: string) => CliEntryIdentifier;
+export declare const asCliPageIdentifier: (value: string) => CliPageIdentifier;
+export declare const asCliBlockIdentifier: (value: string) => CliBlockIdentifier;
+export declare const asCliFormSlug: (value: string) => CliFormSlug;
+export declare const asCliNavigationMenuName: (value: string) => CliNavigationMenuName;

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

@@ -1,76 +1,49 @@
-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 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'>;
@@ -79,7 +52,12 @@ export declare function executeEntryCommandPlanAsSyncResult(input: CliEntryComma
 export declare function syncResultForEntryCommandCompileError(error: CliCommandCompileError): SyncResult;
 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,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

@@ -1,2 +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

@@ -1,30 +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 { executeSyncPlan, type ContentDiff, type SyncResult } from '../sync';
-export type PushContentExecutionMode = Readonly<{
-    kind: 'entry-command';
+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<{
-    kind: 'legacy-sync';
+    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 pushContentExecutionMode(input: Readonly<{
-    pushScope: string;
-    siteId: string;
-    target: EnvTarget;
-    diff: ContentDiff;
-    local: LocalContent;
-}>): PushContentExecutionMode;
 export declare function executeContentPushPlan(input: Readonly<{
-    pushScope: string;
-    siteId: string;
+    pushScope: PushScope;
+    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;
+    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 {};