@riverbankcms/sdk 0.67.0 → 0.70.0

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

@@ -0,0 +1,32 @@
+import type { SiteId } from '../../../../../../core/src/index';
+import { type CliDatedOfferingCommandBatchSource, type CliDatedOfferingCommandCompileInput, type DatedOfferingReportSubject, type DatedOfferingUpsertItem } from '../../../site-commands';
+import type { WriterOptions } from '../../../content/writer';
+import type { PushScopeResult, ScopePushContext } from './types';
+type CommandBackedDatedOfferingScopeConfig<TLocal, TRemote> = Readonly<{
+    source: CliDatedOfferingCommandBatchSource;
+    scopeName: string;
+    itemLabelSingular: string;
+    scopeCommand: DatedOfferingReportSubject['scopeCommand'];
+    getIdentifier: (item: TLocal) => string;
+    getDisplayLabel: (item: TLocal) => string;
+    shouldPushItem?: (item: TLocal) => boolean;
+    readLocal: (contentDir: string) => Promise<TLocal[]>;
+    readMeta: (contentDir: string) => Promise<Record<string, {
+        updatedAt?: string;
+    }> | null>;
+    fetchRemote: () => Promise<TRemote[]>;
+    getRemoteUpdatedAt: (remote: TRemote) => string;
+    findRemote: (remoteItems: readonly TRemote[], identifier: string) => TRemote | undefined;
+    getRemoteIdentifier: (remote: TRemote) => string;
+    updateLocalMeta: (contentDir: string, options?: WriterOptions) => Promise<void>;
+    readOnlyStatusWarning?: (item: TLocal) => string | null;
+    buildCompileInput: (input: Readonly<{
+        source: CliDatedOfferingCommandBatchSource;
+        siteId: SiteId;
+        targetEnv: ScopePushContext['targetEnv'];
+        upserts: readonly DatedOfferingUpsertItem<TLocal>[];
+        deletes: readonly string[];
+    }>) => CliDatedOfferingCommandCompileInput;
+}>;
+export declare function pushCommandBackedDatedOfferingScope<TLocal, TRemote>(ctx: ScopePushContext, config: CommandBackedDatedOfferingScopeConfig<TLocal, TRemote>): Promise<PushScopeResult>;
+export {};

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

@@ -1,9 +1,13 @@
 import type { OutputContext } from '../../../output';
 import type { ManagementClient } from '../../../../client/management';
 import type { WriterOptions } from '../../../content/writer';
+import type { SiteId } from '../../../../../../core/src/index';
+import type { EnvTarget } from '../../../helpers';
 export interface ScopePushContext {
     output: OutputContext;
     contentDir: string;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
     client: ManagementClient;
     dryRun: boolean;
     force: boolean;
@@ -14,7 +18,7 @@ export interface ScopePushContext {
     skipMeta: boolean;
     humanDiff: boolean;
 }
-export type PushScopeResultStatus = 'noop' | 'dry-run' | 'aborted' | 'pushed';
+export type PushScopeResultStatus = 'noop' | 'dry-run' | 'aborted' | 'failed' | 'pushed';
 export interface PushScopeItemError {
     identifier: string;
     error: string;

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

@@ -4,7 +4,7 @@
  * Reads content from the file system for push operations.
  * Mirrors the structure created by writer.ts.
  */
-import type { NavigationLinkInput } from '@riverbankcms/api';
+import type { NavigationLinkInput } from '../../../../api/src/index';
 import type { Theme } from '../../contracts';
 export interface LocalEntry {
     identifier: string;

package/dist/_dts/sdk/src/cli/env.d.ts

@@ -3,7 +3,7 @@
  *
  * Loads and validates environment variables for SDK CLI commands.
  */
-import { type SiteId } from '@riverbankcms/core';
+import { type SiteId } from '../../../core/src/index';
 /**
  * SDK environment configuration
  */

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

@@ -1,4 +1,4 @@
-import { type SiteId } from '@riverbankcms/core';
+import { type SiteId } from '../../../../core/src/index';
 import type { ManagementClient } from '../../client/management/types';
 import type { LocalEntry } from '../content/reader';
 import type { EnvTarget } from '../helpers';

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

@@ -5,7 +5,7 @@
  */
 import { Command } from 'commander';
 import type { OutputContext } from './output';
-import type { APIEndpoints } from '@riverbankcms/api/public';
+import type { APIEndpoints } from '../../../api/src/public/index';
 interface PushConfigOptions {
     config?: string;
     apiKey?: string;

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

@@ -1,4 +1,4 @@
-import type { Brand } from '@riverbankcms/core';
+import type { Brand } from '../../../../core/src/index';
 export type CliContentTypeKey = Brand<string, 'SdkCliContentTypeKey'>;
 export type CliEntryIdentifier = Brand<string, 'SdkCliEntryIdentifier'>;
 export type CliPageIdentifier = Brand<string, 'SdkCliPageIdentifier'>;

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

@@ -1,7 +1,6 @@
-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 Result, type SiteId } from '../../../../core/src/index';
+import { type DryRunReport, type SiteCommandBatch, type SiteCommandExecutionSuccess, type SiteCommandOf, type SiteCommandPlanFor, type SiteCommandRef, type SiteCommandType, type SiteCommandValidationError } from '../../../../site-commands/src/index';
 import type { EnvTarget } from '../helpers';
-import { type SyncResult } from '../sync';
 export type CliCommandBatchRefInput<TSource extends string = string> = Readonly<{
     source: TSource;
     siteId: SiteId;
@@ -46,7 +45,32 @@ export type CliCommandExecutionReportFailure<TSubject> = Readonly<{
     message: string;
     subject?: TSubject;
 }>;
+export type CliCommandOutcome<TSubject> = Readonly<{
+    status: 'applied';
+    commandRef: SiteCommandRef;
+    commandType: SiteCommandType;
+    subject: TSubject;
+}> | Readonly<{
+    status: 'failed';
+    commandRef: SiteCommandRef;
+    commandType: SiteCommandType;
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+}> | Readonly<{
+    status: 'skipped_by_stop_policy';
+    commandRef: SiteCommandRef;
+    commandType: SiteCommandType;
+    identifier: string;
+    subject: TSubject;
+}> | Readonly<{
+    status: 'compile_failed';
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+}>;
 export type CliCommandExecutionReport<TSubject> = Readonly<{
+    outcomes: readonly CliCommandOutcome<TSubject>[];
     appliedSubjects: readonly TSubject[];
     failure: CliCommandExecutionReportFailure<TSubject> | null;
     warnings: readonly string[];
@@ -94,21 +118,27 @@ export declare function commandExecutionToReport<TCommand extends Readonly<{
     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<{
+export declare function commandCompileFailureToReport<TSubject>(input: Readonly<{
+    identifier: string;
+    message: string;
+    subject?: TSubject;
+    warnings?: readonly string[];
+}>): CliCommandExecutionReport<TSubject>;
+export declare function executeCompiledCliCommandPlanAsReport<TCompiledPlan extends Readonly<{
     plan: Readonly<{
         commands: readonly unknown[];
     }>;
-}>, TExecutionResult>(input: Readonly<{
+}>, TExecutionResult, TSubject>(input: Readonly<{
     compiledPlan: TCompiledPlan;
     onBeforeExecute?: (commandCount: number) => void;
     executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
-    executionToSyncResult: (input: Readonly<{
+    executionToReport: (input: Readonly<{
         execution: TExecutionResult;
         compiledPlan: TCompiledPlan;
-    }>) => SyncResult;
-}>): Promise<SyncResult>;
+    }>) => CliCommandExecutionReport<TSubject>;
+}>): Promise<CliCommandExecutionReport<TSubject>>;
+export declare function reportFromOutcomes<TSubject>(input: Readonly<{
+    outcomes: readonly CliCommandOutcome<TSubject>[];
+    warnings?: readonly string[];
+}>): CliCommandExecutionReport<TSubject>;
+export declare function commandReportHasFailures(report: CliCommandExecutionReport<unknown>): boolean;

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

@@ -0,0 +1,21 @@
+import { type SyncResult } from '../sync';
+import { type CliCommandExecutionReport } from './commandRuntime';
+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, TSubject>(input: Readonly<{
+    compiledPlan: TCompiledPlan;
+    onBeforeExecute?: (commandCount: number) => void;
+    executePlan: (plan: TCompiledPlan['plan']) => Promise<TExecutionResult>;
+    executionToReport: (input: Readonly<{
+        execution: TExecutionResult;
+        compiledPlan: TCompiledPlan;
+    }>) => CliCommandExecutionReport<TSubject>;
+    reportToSyncResult: (report: CliCommandExecutionReport<TSubject>) => SyncResult;
+}>): Promise<SyncResult>;

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

@@ -0,0 +1,27 @@
+import { type Result, type SiteId } from '../../../../core/src/index';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalContent } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { ContentDiff, SyncResult } from '../sync';
+import { compilePagePushCommands } from './pageCommands';
+import type { CommandSurface, CommandSurfaceCompileResult, CommandSurfaceCompileSuccess, CommandSurfaceExecutionReport, CompiledContentPushExecutionPlan, CompiledContentPushExecutionStep, ContentPushExecutionPlan, ContentPushExecutionReport } from './pushExecutionTypes';
+export type CommandSurfaceDispatchInput = Readonly<{
+    siteId: SiteId;
+    target: EnvTarget;
+    diff: ContentDiff;
+    local: LocalContent;
+    client: ManagementClient;
+    blockFieldExtensions: Parameters<typeof compilePagePushCommands>[0]['blockFieldExtensions'];
+    onEntryCommandCount?: (commandCount: number) => void;
+    onFormCommandCount?: (commandCount: number) => void;
+    onNavigationCommandCount?: (commandCount: number) => void;
+    onPageCommandCount?: (commandCount: number) => void;
+}>;
+export type CommandSurfaceDispatchDependencies = Readonly<{
+    compileCommandSurface?: (surface: CommandSurface, input: CommandSurfaceDispatchInput) => CommandSurfaceCompileResult;
+    executeCommandSurfaceAsReport?: (surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput) => Promise<CommandSurfaceExecutionReport>;
+}>;
+export declare function compileContentPushExecutionPlan(plan: ContentPushExecutionPlan, input: CommandSurfaceDispatchInput, dependencies?: CommandSurfaceDispatchDependencies): Result<CompiledContentPushExecutionPlan, ContentPushExecutionReport>;
+export declare function executeCommandSurfaceAsReport(surface: CommandSurfaceCompileSuccess, input: CommandSurfaceDispatchInput): Promise<CommandSurfaceExecutionReport>;
+export declare function skippedRemainingCommandReports(steps: readonly CompiledContentPushExecutionStep[]): CommandSurfaceExecutionReport[];
+export declare function commandSurfaceReportToSyncResult(report: CommandSurfaceExecutionReport): SyncResult;

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

@@ -0,0 +1,56 @@
+import { type Result, type SiteId } from '../../../../core/src/index';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalCourse, LocalEvent, LocalEventCategory, LocalVenue } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { PushScopeResult } from '../commands/push/scopes/types';
+import { type CliCommandCompileBatchSuccessWithReports, type CliCommandValidationCompileError } from './commandRuntime';
+export type CliDatedOfferingCommandBatchSource = 'push_venues' | 'push_event_categories' | 'push_events' | 'push_courses' | 'push_all_dated_offerings';
+export type DatedOfferingSiteCommandType = 'upsertVenue' | 'deleteVenue' | 'upsertEventCategory' | 'deleteEventCategory' | 'upsertEventSeries' | 'deleteEventSeries' | 'upsertCourse' | 'deleteCourse';
+type DatedOfferingCounter = 'created' | 'updated' | 'deleted';
+export type DatedOfferingReportSubject = Readonly<{
+    scopeCommand: 'venues' | 'event-categories' | 'events' | 'courses';
+    scopeName: string;
+    itemLabelSingular: string;
+    identifier: string;
+    counter: DatedOfferingCounter;
+}>;
+export type CliDatedOfferingCommandCompileError = Readonly<{
+    code: 'unsupported_local_shape';
+    identifier: string;
+    message: string;
+}> | CliCommandValidationCompileError;
+export type CliDatedOfferingCommandCompileInput = Readonly<{
+    source: CliDatedOfferingCommandBatchSource;
+    siteId: SiteId;
+    targetEnv: EnvTarget;
+    venues?: DatedOfferingUpsertInput<LocalVenue>;
+    eventCategories?: DatedOfferingUpsertInput<LocalEventCategory>;
+    events?: DatedOfferingUpsertInput<LocalEvent>;
+    courses?: DatedOfferingUpsertInput<LocalCourse>;
+    delete?: DatedOfferingDeleteInput;
+}>;
+export type DatedOfferingUpsertInput<TItem> = Readonly<{
+    items: readonly DatedOfferingUpsertItem<TItem>[];
+}>;
+export type DatedOfferingUpsertItem<TItem> = Readonly<{
+    item: TItem;
+    exists: boolean;
+}>;
+export type DatedOfferingDeleteInput = Readonly<{
+    venues?: readonly string[];
+    eventCategories?: readonly string[];
+    events?: readonly string[];
+    courses?: readonly string[];
+}>;
+export type CliDatedOfferingCommandCompileSuccess = CliCommandCompileBatchSuccessWithReports<DatedOfferingSiteCommandType, DatedOfferingReportSubject>;
+export declare const datedOfferingSiteCommandTypes: readonly ["upsertVenue", "deleteVenue", "upsertEventCategory", "deleteEventCategory", "upsertEventSeries", "deleteEventSeries", "upsertCourse", "deleteCourse"];
+export declare function compileDatedOfferingPushCommands(input: CliDatedOfferingCommandCompileInput): Result<CliDatedOfferingCommandCompileSuccess, CliDatedOfferingCommandCompileError>;
+export declare function executeDatedOfferingCommandPlanAsPushScopeResult(input: Readonly<{
+    client: Pick<ManagementClient, 'venues' | 'eventCategories' | 'events' | 'courses'>;
+    compiledPlan: CliDatedOfferingCommandCompileSuccess;
+    scopeCommand: DatedOfferingReportSubject['scopeCommand'];
+    scopeName: string;
+}>): Promise<PushScopeResult>;
+export declare function syncResultForDatedOfferingCommandCompileError(error: CliDatedOfferingCommandCompileError, scopeCommand: DatedOfferingReportSubject['scopeCommand'], scopeName: string): PushScopeResult;
+export declare function courseSessionConflictMessage(error: unknown): string;
+export {};

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

@@ -1,10 +1,10 @@
-import { type Result, type SiteId } from '@riverbankcms/core';
-import { type AllowedRuntime, type SiteCommandOf } from '@riverbankcms/site-commands';
+import { type Result, type SiteId } from '../../../../core/src/index';
+import { type AllowedRuntime, type SiteCommandOf } from '../../../../site-commands/src/index';
 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';
@@ -49,7 +49,9 @@ export declare function executeEntryCommandPlan(input: Readonly<{
     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;
     compiledPlan: EntryCommandCompiledPlan;

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

@@ -1,10 +1,10 @@
-import { type Result, type SiteId } from '@riverbankcms/core';
-import { type SiteCommandOf } from '@riverbankcms/site-commands';
+import { type Result, type SiteId } from '../../../../core/src/index';
+import { type SiteCommandOf } from '../../../../site-commands/src/index';
 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 { 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;
@@ -37,7 +37,13 @@ export declare function executeFooterCommandPlanAsSyncResult(input: Readonly<{
     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;

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

@@ -1,10 +1,10 @@
-import { type Result, type SiteId } from '@riverbankcms/core';
-import { type SiteCommandOf } from '@riverbankcms/site-commands';
+import { type Result, type SiteId } from '../../../../core/src/index';
+import { type SiteCommandOf } from '../../../../site-commands/src/index';
 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 CliFormSlug } from './commandKeys';
 import { type CliCommandCompileBatchSuccessWithReports, type CliCommandExecutionError, type CliCommandExecutionReport, type CliCommandExecutionResult, type CliCommandValidationCompileError } from './commandRuntime';
 export type CliFormCommandBatchSource = 'push_forms';
@@ -39,16 +39,12 @@ export declare function executeFormCommandPlan(input: Readonly<{
     client: Pick<ManagementClient, 'forms'>;
     plan: Pick<FormSiteCommandPlan, 'commands'>;
 }>): Promise<CliFormCommandExecutionResult>;
-export declare function executeFormCommandPlanAsSyncResult(input: Readonly<{
+export declare function executeFormCommandPlanAsReport(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;
+}>): Promise<FormCommandExecutionReport>;
+export declare function formCommandCompileErrorToReport(error: CliFormCommandCompileError): FormCommandExecutionReport;
 export declare function formCommandExecutionToReport(input: Readonly<{
     execution: CliFormCommandExecutionResult;
     compiledPlan: FormCommandCompiledPlan;

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

@@ -1,4 +1,5 @@
 export * from './commandRuntime';
+export * from './datedOfferingCommands';
 export * from './entryCommands';
 export * from './formCommands';
 export * from './footerCommands';

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

@@ -1,10 +1,10 @@
-import { type Result, type SiteId } from '@riverbankcms/core';
-import { type SiteCommandOf } from '@riverbankcms/site-commands';
+import { type Result, type SiteId } from '../../../../core/src/index';
+import { type SiteCommandOf } from '../../../../site-commands/src/index';
 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 { 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';
@@ -39,16 +39,12 @@ export declare function executeNavigationCommandPlan(input: Readonly<{
     client: Pick<ManagementClient, 'navigation'>;
     plan: Pick<NavigationSiteCommandPlan, 'commands'>;
 }>): Promise<CliNavigationCommandExecutionResult>;
-export declare function executeNavigationCommandPlanAsSyncResult(input: Readonly<{
+export declare function executeNavigationCommandPlanAsReport(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;
+}>): Promise<NavigationCommandExecutionReport>;
+export declare function navigationCommandCompileErrorToReport(error: CliNavigationCommandCompileError): NavigationCommandExecutionReport;
 export declare function navigationCommandExecutionToReport(input: Readonly<{
     execution: CliNavigationCommandExecutionResult;
     compiledPlan: NavigationCommandCompiledPlan;

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

@@ -1,11 +1,11 @@
-import { type Result, type SiteId } from '@riverbankcms/core';
-import { type SiteCommandOf } from '@riverbankcms/site-commands';
+import { type Result, type SiteId } from '../../../../core/src/index';
+import { type SiteCommandOf } from '../../../../site-commands/src/index';
 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 { 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';
@@ -65,16 +65,12 @@ export declare function executePageCommandPlan(input: Readonly<{
     client: Pick<ManagementClient, 'pages' | 'blocks'>;
     plan: Pick<PageSiteCommandPlan, 'commands'>;
 }>): Promise<CliPageCommandExecutionResult>;
-export declare function executePageCommandPlanAsSyncResult(input: Readonly<{
+export declare function executePageCommandPlanAsReport(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;
+}>): Promise<PageCommandExecutionReport>;
+export declare function pageCommandCompileErrorToReport(error: CliPageCommandCompileError): PageCommandExecutionReport;
 export declare function pageCommandExecutionToReport(input: Readonly<{
     execution: CliPageCommandExecutionResult;
     compiledPlan: PageCommandCompiledPlan;

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

@@ -1,65 +1,17 @@
-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 SiteId } from '../../../../core/src/index';
 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;
+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;
@@ -71,13 +23,7 @@ export declare function executeContentPushPlan(input: Readonly<{
     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 {};
+}>;
+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;