@riverbankcms/sdk 0.96.0 → 0.99.0

package/dist/_dts/field-primitives/src/bindings/index.d.ts

@@ -0,0 +1,8 @@
+export declare const BINDING_TRANSFORMS: {
+    readonly RICHTEXT_FIRST_PARAGRAPH: "richtext.firstParagraph";
+    readonly DATE_FORMAT_SHORT: "date.formatShort";
+    readonly DATE_FORMAT_LONG: "date.formatLong";
+    readonly TEXT_INLINE_TEXT: "text.inlineText";
+};
+export type BindingTransformName = (typeof BINDING_TRANSFORMS)[keyof typeof BINDING_TRANSFORMS];
+export declare const BINDING_TRANSFORM_VALUES: [BindingTransformName, ...BindingTransformName[]];

package/dist/_dts/sdk/src/__mocks__/next-cache.d.ts

@@ -1,7 +1,7 @@
 /**
  * Mock implementation of next/cache for testing
  */
-import { vi } from 'vitest';
+import { vi } from 'bun:test';
 export declare const revalidateTag: ReturnType<typeof vi.fn<(tag: string, profile?: string) => void>>;
 export declare const revalidatePath: ReturnType<typeof vi.fn<(path: string) => void>>;
 export declare const unstable_cache: <T extends (...args: never[]) => unknown>(fn: T) => T;

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

@@ -0,0 +1,15 @@
+import type { LocalContent } from '../../content/reader';
+import type { ContentDiff } from '../../sync';
+import type { EnvTarget } from '../../helpers';
+export type PublishGuidanceEntry = Readonly<{
+    contentType: string;
+    identifier: string;
+}>;
+export declare function collectUpdatedPublishedEntriesForGuidance(input: Readonly<{
+    diff: Pick<ContentDiff, 'entries'>;
+    local: Pick<LocalContent, 'entries'>;
+}>): readonly PublishGuidanceEntry[];
+export declare function buildPublishAllSuggestion(input: Readonly<{
+    entries: readonly PublishGuidanceEntry[];
+    target: EnvTarget;
+}>): string;

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

@@ -2,6 +2,7 @@ import type { SiteId } from '../../../../../../core/src/index';
 import { type FieldChange, type JsonDiffMode } from '../../../sync';
 import { type CliDatedOfferingCommandBatchSource, type CliDatedOfferingCommandCompileInput, type DatedOfferingReportSubject, type DatedOfferingUpsertItem } from '../../../site-commands';
 import type { WriterOptions } from '../../../content/writer';
+import type { ContentMetadataTarget } from '../../../content/metadataStore';
 import type { PushScopeResult, ScopePushContext } from './types';
 import type { LocalMediaPushReport } from '../../../media/local-sync';
 type CommandBackedDatedOfferingScopeConfig<TLocal, TRemote> = Readonly<{
@@ -13,7 +14,7 @@ type CommandBackedDatedOfferingScopeConfig<TLocal, TRemote> = Readonly<{
     getDisplayLabel: (item: TLocal) => string;
     shouldPushItem?: (item: TLocal) => boolean;
     readLocal: (contentDir: string) => Promise<TLocal[]>;
-    readMeta: (contentDir: string) => Promise<Record<string, {
+    readMeta: (contentDir: string, metadataTarget?: ContentMetadataTarget) => Promise<Record<string, {
         updatedAt?: string;
     }> | null>;
     fetchRemote: () => Promise<TRemote[]>;

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

@@ -5,12 +5,14 @@ import type { SiteId } from '../../../../../../core/src/index';
 import type { EnvTarget } from '../../../helpers';
 import type { JsonDiffMode } from '../../../sync';
 import type { LocalMediaPushReport } from '../../../media/local-sync';
+import type { ContentMetadataTarget } from '../../../content/metadataStore';
 export type PushMediaPolicy = 'require' | 'allow-missing';
 export interface ScopePushContext {
     output: OutputContext;
     contentDir: string;
     siteId: SiteId;
     targetEnv: EnvTarget;
+    metadataTarget: ContentMetadataTarget;
     client: ManagementClient;
     dryRun: boolean;
     force: boolean;
@@ -60,7 +62,7 @@ export interface PushScopeConfig<TLocal, TRemote> {
     /** Read local items from content directory */
     readLocal: (contentDir: string) => Promise<TLocal[]>;
     /** Read local metadata for stale detection */
-    readMeta: (contentDir: string) => Promise<Record<string, {
+    readMeta: (contentDir: string, metadataTarget?: ContentMetadataTarget) => Promise<Record<string, {
         updatedAt?: string;
     }> | null>;
     /** Fetch remote items */

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

@@ -1,3 +1,4 @@
+import { type ContentMetadataTarget } from '../../content/metadataStore';
 import type { OutputContext } from '../../output';
 import type { PulledContent } from '../../../client/management/types';
 import type { StaleItem } from './stale';
@@ -18,7 +19,7 @@ export declare function resolveStaleOrAbort(opts: {
     yes: boolean;
 }): Promise<'resolve' | 'abort'>;
 /**
- * Write only the stale entries/pages/navigation/forms from the already-fetched
+ * Write only the stale entries/pages/navigation/forms/settings from the already-fetched
  * remoteContent to disk and update their metadata. Non-stale local content is
  * preserved — we only touch the specific items identified as stale.
  *
@@ -29,14 +30,19 @@ export declare function resolveStaleOrAbort(opts: {
  */
 export declare function writeStaleItems(contentDir: string, remoteContent: PulledContent, staleItems: StaleItem[], output: OutputContext, options?: {
     skipMeta?: boolean;
+    metadataTarget?: ContentMetadataTarget;
 }): Promise<void>;
 /**
  * Update only the theme metadata timestamp without touching the theme content file.
  * Used when the local theme IS the content being pushed — we just need to acknowledge
  * the remote is newer so stale detection passes on the next push.
  */
-export declare function updateStaleThemeMeta(contentDir: string, themeName: string, remoteUpdatedAt: string): Promise<void>;
+export declare function updateStaleThemeMeta(contentDir: string, themeName: string, remoteUpdatedAt: string, options?: {
+    metadataTarget?: ContentMetadataTarget;
+}): Promise<void>;
 /**
  * Update only the footer metadata timestamp without touching the footer content file.
  */
-export declare function updateStaleFooterMeta(contentDir: string, remoteUpdatedAt: string): Promise<void>;
+export declare function updateStaleFooterMeta(contentDir: string, remoteUpdatedAt: string, options?: {
+    metadataTarget?: ContentMetadataTarget;
+}): Promise<void>;

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

@@ -0,0 +1,34 @@
+import type { PushScope } from './consts';
+export type PushWorkflowStep = Readonly<{
+    tag: 'config';
+    mode: 'apply';
+}> | Readonly<{
+    tag: 'content';
+}>;
+export type PushWorkflowPreContentStep = Extract<PushWorkflowStep, {
+    tag: 'config';
+}>;
+export type PushWorkflowPlan = Readonly<{
+    steps: readonly PushWorkflowStep[];
+    warnings: readonly PushWorkflowWarning[];
+}>;
+export type PushWorkflowWarning = Readonly<{
+    tag: 'with_config_ignored_for_scope';
+    pushScope: PushScope;
+}>;
+export type PlanPushWorkflowInput = Readonly<{
+    pushScope: PushScope;
+    withConfig: boolean;
+    dryRun: boolean;
+}>;
+export declare function planPushWorkflow(input: PlanPushWorkflowInput): PushWorkflowPlan;
+export declare function shouldApplyConfigBeforeContent(plan: PushWorkflowPlan): boolean;
+export declare function preContentWorkflowSteps(plan: PushWorkflowPlan): readonly PushWorkflowPreContentStep[];
+export type PushWorkflowPreContentHandlers = Readonly<{
+    [TStep in PushWorkflowPreContentStep as TStep['tag']]: (step: TStep) => Promise<boolean>;
+}>;
+export declare function runPushWorkflowPreContentSteps(plan: PushWorkflowPlan, handlers: PushWorkflowPreContentHandlers): Promise<Readonly<{
+    success: true;
+}> | Readonly<{
+    success: false;
+}>>;

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

@@ -19,9 +19,22 @@
  *   riverbankcms push --dry-run          # Show what would be pushed
  */
 import { Command } from 'commander';
+import { allEnvSucceeded, getOutputContext, runForEnvironments } from '../helpers';
+import { executePushForEnv } from './push-execute';
+import { emitPushVerificationResult, isPushVerificationClean, verifyPushNoopForEnv } from './push/verification';
 export { contentSummaryHasPushableContent, noContentFoundWarningDetails } from './push-execute';
 export { VALID_PUSH_SCOPES, isValidPushScope, type PushScope } from './push/consts';
 export { calculateMetadataUpdates, type MetadataUpdateFlags } from './push/metadata';
 export { filterLocalContent, type FilterResult } from './push/filter';
 export { checkForStaleContent, type StaleItem } from './push/stale';
+export type PushCommandDeps = Readonly<{
+    getOutputContext: typeof getOutputContext;
+    runForEnvironments: typeof runForEnvironments;
+    allEnvSucceeded: typeof allEnvSucceeded;
+    executePushForEnv: typeof executePushForEnv;
+    verifyPushNoopForEnv: typeof verifyPushNoopForEnv;
+    emitPushVerificationResult: typeof emitPushVerificationResult;
+    isPushVerificationClean: typeof isPushVerificationClean;
+}>;
+export declare function createPushCommand(deps?: PushCommandDeps): Command;
 export declare const pushCommand: Command;

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

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const setupCommand: Command;

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

@@ -4,6 +4,7 @@
  * Loads riverbank.config.ts and extracts CLI-relevant configuration
  * (contentDir and sync settings) with appropriate defaults.
  */
+import type { EnvTarget } from './helpers';
 import type { SyncConfig, BlockFieldExtensionsMap, SdkCustomBlock } from '../config/types';
 /**
  * Loaded CLI configuration with defaults applied.
@@ -36,6 +37,7 @@ export interface LoadedCliConfig {
  * ```
  */
 export declare function loadCliConfig(configPath?: string): Promise<LoadedCliConfig>;
+export declare function loadCliConfigForEnv(target: EnvTarget, configPath?: string): Promise<LoadedCliConfig>;
 /**
  * Check if a CLI config file exists.
  *

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

@@ -0,0 +1,29 @@
+import type { SdkEnvironment } from '../env';
+export type ContentMetadataEnv = 'local' | 'remote';
+export type ContentMetadataTarget = Readonly<{
+    env: ContentMetadataEnv;
+    siteId: string;
+    dashboardUrl: string;
+}>;
+export type ContentMetadataReadPath = Readonly<{
+    path: string;
+    source: 'scoped' | 'legacy';
+}>;
+export declare function metadataTargetFromEnvironment(env: ContentMetadataEnv, environment: Pick<SdkEnvironment, 'siteId' | 'dashboardUrl'>): ContentMetadataTarget;
+export declare function legacyMetadataDir(contentDir: string): string;
+export declare function scopedMetadataDir(contentDir: string, target: ContentMetadataTarget): string;
+export declare function metadataFilePath(contentDir: string, fileName: string, target?: ContentMetadataTarget): string;
+export declare function legacyMetadataFilePath(contentDir: string, fileName: string): string;
+export declare function ensureMetadataDir(contentDir: string, target?: ContentMetadataTarget): Promise<string>;
+export declare function writeMetadataFile(contentDir: string, fileName: string, value: unknown, target?: ContentMetadataTarget): Promise<string>;
+export declare function readMetadataFile<T>(contentDir: string, fileName: string, target?: ContentMetadataTarget): Promise<T | null>;
+export declare function listMetadataFiles(contentDir: string, target?: ContentMetadataTarget): Promise<string[]>;
+export declare function writeMetadataRecordMap<TRecord>(contentDir: string, fileName: string, recordKey: string, next: Readonly<{
+    pulledAt: string;
+    records: Readonly<Record<string, TRecord>>;
+    extra?: Readonly<Record<string, unknown>>;
+}>, options?: Readonly<{
+    mode?: 'replace' | 'merge';
+    target?: ContentMetadataTarget;
+}>): Promise<string>;
+export declare function resolveMetadataReadPath(contentDir: string, fileName: string, target?: ContentMetadataTarget): Promise<ContentMetadataReadPath | null>;

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

@@ -4,6 +4,7 @@
  * Reads content from the file system for push operations.
  * Mirrors the structure created by writer.ts.
  */
+import { type ContentMetadataTarget } from './metadataStore';
 import type { NavigationAuthoringLinkInput, NavigationLocalItemInput } from '../../../../api/src/navigation';
 import type { SdkEventPricingInput } from '../../../../api/src/sdk-event-pricing';
 import type { EventPaymentTermsInput } from '../../client/management/types';
@@ -233,7 +234,7 @@ export declare function findLegacyEntryFiles(contentDir: string): Promise<string
  * @param contentType - Optional specific content type to read
  * @returns Map of content type to entries
  */
-export declare function readEntries(contentDir: string, contentType?: string): Promise<Map<string, LocalEntry[]>>;
+export declare function readEntries(contentDir: string, contentType?: string, metadataTarget?: ContentMetadataTarget): Promise<Map<string, LocalEntry[]>>;
 /**
  * Read pages from content directory
  *
@@ -350,7 +351,7 @@ export interface LocalContent {
     events: LocalEvent[];
     courses: LocalCourse[];
 }
-export declare function readAllContent(contentDir: string): Promise<LocalContent>;
+export declare function readAllContent(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<LocalContent>;
 /**
  * Check if content directory exists and has content
  */
@@ -387,6 +388,7 @@ export interface EntryMetadata {
         createdAt?: string;
         updatedAt?: string;
         publishedAt?: string;
+        hasUnpublishedChanges?: boolean;
     }>;
 }
 export interface PagesMetadata {
@@ -414,35 +416,35 @@ export interface SettingsMetadata {
  * @param contentType - Content type to read metadata for
  * @returns Metadata or null if not found
  */
-export declare function readEntriesMeta(contentDir: string, contentType: string): Promise<EntryMetadata | null>;
+export declare function readEntriesMeta(contentDir: string, contentType: string, metadataTarget?: ContentMetadataTarget): Promise<EntryMetadata | null>;
 /**
  * Read all entry metadata files from .meta/ directory
  *
  * @param contentDir - Base content directory
  * @returns Map of content type to metadata
  */
-export declare function readAllMeta(contentDir: string): Promise<Map<string, EntryMetadata>>;
+export declare function readAllMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<Map<string, EntryMetadata>>;
 /**
  * Read settings metadata from .meta/settings.json
  *
  * @param contentDir - Base content directory
  * @returns Settings metadata or null if not found
  */
-export declare function readSettingsMeta(contentDir: string): Promise<SettingsMetadata | null>;
+export declare function readSettingsMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<SettingsMetadata | null>;
 /**
  * Read pages metadata from .meta/pages.json
  *
  * @param contentDir - Base content directory
  * @returns Pages metadata or null if not found
  */
-export declare function readPagesMeta(contentDir: string): Promise<PagesMetadata | null>;
+export declare function readPagesMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<PagesMetadata | null>;
 /**
  * Read navigation metadata from .meta/navigation.json
  *
  * @param contentDir - Base content directory
  * @returns Navigation metadata or null if not found
  */
-export declare function readNavigationMeta(contentDir: string): Promise<NavigationMetadata | null>;
+export declare function readNavigationMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<NavigationMetadata | null>;
 export interface FormsMetadata {
     pulledAt: string;
     forms: Record<string, {
@@ -456,7 +458,7 @@ export interface FormsMetadata {
  * @param contentDir - Base content directory
  * @returns Forms metadata or null if not found
  */
-export declare function readFormsMeta(contentDir: string): Promise<FormsMetadata | null>;
+export declare function readFormsMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<FormsMetadata | null>;
 export interface ThemesMetadata {
     pulledAt: string;
     themes: Record<string, {
@@ -471,7 +473,7 @@ export interface ThemesMetadata {
  * @param contentDir - Base content directory
  * @returns Themes metadata or null if not found
  */
-export declare function readThemesMeta(contentDir: string): Promise<ThemesMetadata | null>;
+export declare function readThemesMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<ThemesMetadata | null>;
 export interface VenuesMetadata {
     pulledAt: string;
     venues: Record<string, {
@@ -485,7 +487,7 @@ export interface VenuesMetadata {
  * @param contentDir - Base content directory
  * @returns Venues metadata or null if not found
  */
-export declare function readVenuesMeta(contentDir: string): Promise<VenuesMetadata | null>;
+export declare function readVenuesMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<VenuesMetadata | null>;
 export interface EventCategoriesMetadata {
     pulledAt: string;
     eventCategories: Record<string, {
@@ -499,7 +501,7 @@ export interface EventCategoriesMetadata {
  * @param contentDir - Base content directory
  * @returns Event categories metadata or null if not found
  */
-export declare function readEventCategoriesMeta(contentDir: string): Promise<EventCategoriesMetadata | null>;
+export declare function readEventCategoriesMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<EventCategoriesMetadata | null>;
 export interface EventsMetadata {
     pulledAt: string;
     events: Record<string, {
@@ -520,14 +522,14 @@ export interface CoursesMetadata {
  * @param contentDir - Base content directory
  * @returns Events metadata or null if not found
  */
-export declare function readEventsMeta(contentDir: string): Promise<EventsMetadata | null>;
+export declare function readEventsMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<EventsMetadata | null>;
 /**
  * Read courses metadata from .meta/courses.json
  *
  * @param contentDir - Base content directory
  * @returns Courses metadata or null if not found
  */
-export declare function readCoursesMeta(contentDir: string): Promise<CoursesMetadata | null>;
+export declare function readCoursesMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<CoursesMetadata | null>;
 export interface FooterMetadata {
     pulledAt: string;
     updatedAt?: string;
@@ -538,4 +540,4 @@ export interface FooterMetadata {
  * @param contentDir - Base content directory
  * @returns Footer metadata or null if not found
  */
-export declare function readFooterMeta(contentDir: string): Promise<FooterMetadata | null>;
+export declare function readFooterMeta(contentDir: string, metadataTarget?: ContentMetadataTarget): Promise<FooterMetadata | null>;

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

@@ -5,17 +5,19 @@
  */
 import type { PulledEntries, PulledPages, PulledNavigation, PulledSettings, PulledForms, PulledTheme, PulledFooter, PulledVenues, PulledEventCategories, PulledEvents, PulledCourses } from '../../client/management/types';
 import type { Theme } from '../../contracts';
-import { type PulledEntryOutput } from '../helpers';
+import { type EntryForOutput } from '../helpers';
 import type { EntryBaseSnapshotTarget } from '../merge-remote/entrySnapshots';
 import type { PageBaseSnapshotTarget } from '../merge-remote/pageSnapshots';
+import { type ContentMetadataTarget } from './metadataStore';
 export interface WriterOptions {
     skipMeta?: boolean;
     cleanupMissing?: boolean;
+    metadataTarget?: ContentMetadataTarget;
     entryBaseSnapshot?: EntryBaseSnapshotTarget;
     pageBaseSnapshot?: PageBaseSnapshotTarget;
 }
 type WritablePulledEntries = Omit<PulledEntries, 'entries'> & {
-    entries: PulledEntryOutput[];
+    entries: EntryForOutput[];
 };
 /**
  * Write entries to content directory
@@ -92,7 +94,7 @@ export declare function writeThemesMeta(contentDir: string, meta: {
         selectionId: string;
         updatedAt: string;
     }>;
-}): Promise<void>;
+}, options?: Pick<WriterOptions, 'metadataTarget'>): Promise<void>;
 /**
  * Write a pulled theme to content directory with metadata
  *
@@ -207,7 +209,7 @@ export declare function updateMetadataAfterPush(contentDir: string, remoteConten
         updatedAt: string;
         createdAt?: string;
     }>;
-}): Promise<void>;
+}, options?: Pick<WriterOptions, 'metadataTarget'>): Promise<void>;
 export declare function writeAllContent(contentDir: string, content: {
     entries: Record<string, PulledEntries['entries']>;
     pages: PulledPages;

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

@@ -0,0 +1,2 @@
+import type { EnvTarget } from './helpers';
+export declare function withRiverbankEnv<T>(target: EnvTarget, run: () => Promise<T>): Promise<T>;

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

@@ -85,17 +85,16 @@ export interface ParsedPagination {
  */
 export type RowFormatter<T> = (item: T) => string[];
 /**
- * Entry format for SDK pull operations.
- * Matches the server-side PulledEntry type.
+ * Entry format written to content/entries/*.json.
+ * Operational fields such as manual ordering and unpublished state live in
+ * metadata so entry files remain authoring-focused.
  */
-export interface PulledEntryOutput {
+export interface EntryContentFileOutput {
     identifier: string;
     data: Record<string, unknown>;
     status: 'draft' | 'published';
-    hasUnpublishedChanges: boolean;
     /** Slug for URL routing - only present for routable content types */
     slug?: string;
-    manualOrder?: number;
     blocks?: Record<string, Array<{
         identifier: string | null;
         kind: string;
@@ -114,9 +113,9 @@ export interface EntryForOutput {
     slug?: string;
     title?: string;
     manualOrder?: number;
-    blocks?: PulledEntryOutput['blocks'];
+    blocks?: EntryContentFileOutput['blocks'];
 }
-export declare function mapEntryForOutput<T extends EntryForOutput>(entry: T): PulledEntryOutput;
+export declare function mapEntryForOutput<T extends EntryForOutput>(entry: T): EntryContentFileOutput;
 /**
  * Parse pagination options from command flags.
  *

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

@@ -1,5 +1,6 @@
 import { type SiteId } from '../../../../core/src/index';
 import type { ManagementClient } from '../../client/management/types';
+import type { ContentMetadataTarget } from '../content/metadataStore';
 import type { LocalEntry } from '../content/reader';
 import type { EnvTarget } from '../helpers';
 import type { OutputContext } from '../output';
@@ -12,6 +13,7 @@ export declare function planAndReportRemoteEntryMerge(input: Readonly<{
     contentDir: string;
     target: EnvTarget;
     siteId: SiteId;
+    metadataTarget: ContentMetadataTarget;
     contentType?: string;
     identifier?: string;
     localEntries: ReadonlyMap<string, readonly LocalEntry[]>;

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

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

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

@@ -1,10 +1,8 @@
 import type { PulledEntries } from '../../client/management/types';
 import type { EntryForOutput, EnvTarget } from '../helpers';
 import type { LocalEntry } from '../content/reader';
-export type EntryBaseSnapshotTarget = Readonly<{
-    env: EnvTarget;
-    siteId: string;
-}>;
+import { type BaseSnapshotTarget } from './sharedBaseSnapshots';
+export type EntryBaseSnapshotTarget = BaseSnapshotTarget;
 export type EntryBaseSnapshotSubject = Readonly<{
     contentType: string;
     identifier: string;

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

@@ -1,5 +1,6 @@
 import type { SiteId } from '../../../../core/src/index';
 import type { ManagementClient } from '../../client/management/types';
+import type { ContentMetadataTarget } from '../content/metadataStore';
 import type { LocalPage } from '../content/reader';
 import type { EnvTarget } from '../helpers';
 import type { OutputContext } from '../output';
@@ -12,6 +13,7 @@ export declare function planAndReportRemotePageMerge(input: Readonly<{
     contentDir: string;
     target: EnvTarget;
     siteId: SiteId;
+    metadataTarget: ContentMetadataTarget;
     identifier?: string;
     localPages: readonly LocalPage[];
     dryRun: boolean;

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

@@ -1,25 +1,12 @@
 import type { OutputContext } from '../output';
-import type { PageMergeConflict, PageMergeDecision } from './pageMerge';
+import type { PageMergeDecision } from './pageMerge';
 import type { RemotePageMergePlan } from './pageMergePlan';
-export type RemotePageMergeJsonReport = Readonly<{
-    kind: 'push';
-    scope: 'pages';
-    mergeRemote: true;
-    dryRun: boolean;
-    summary: RemotePageMergePlan['summary'];
-    decisions: readonly RemotePageMergeDecisionReport[];
-}>;
-export type RemotePageMergeDecisionReport = Readonly<{
-    kind: PageMergeDecision['kind'];
+import { type RemoteMergeDecisionReport, type RemoteMergeJsonReport } from './sharedMergeReport';
+type RemotePageMergeSubjectJson = Readonly<{
     identifier: string;
-    localFieldPaths?: readonly string[];
-    remoteFieldPaths?: readonly string[];
-    conflict?: Readonly<{
-        code: PageMergeConflict['code'];
-        fieldPath?: string;
-        message: string;
-    }>;
 }>;
+export type RemotePageMergeDecisionReport = RemoteMergeDecisionReport<PageMergeDecision, RemotePageMergeSubjectJson>;
+export type RemotePageMergeJsonReport = RemoteMergeJsonReport<'pages', RemotePageMergePlan['summary'], PageMergeDecision, RemotePageMergeSubjectJson>;
 export declare function remotePageMergeJsonReport(input: Readonly<{
     plan: RemotePageMergePlan;
     dryRun: boolean;
@@ -27,3 +14,4 @@ export declare function remotePageMergeJsonReport(input: Readonly<{
 export declare function writeRemotePageMergeHumanReport(output: Pick<OutputContext, 'info'>, plan: RemotePageMergePlan, options: Readonly<{
     dryRun: boolean;
 }>): void;
+export {};

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

@@ -1,10 +1,8 @@
 import type { PulledPages } from '../../client/management/types';
 import type { EnvTarget } from '../helpers';
 import type { LocalPage } from '../content/reader';
-export type PageBaseSnapshotTarget = Readonly<{
-    env: EnvTarget;
-    siteId: string;
-}>;
+import { type BaseSnapshotTarget } from './sharedBaseSnapshots';
+export type PageBaseSnapshotTarget = BaseSnapshotTarget;
 export type PageBaseSnapshotSubject = Readonly<{
     identifier: string;
 }>;

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

@@ -0,0 +1,32 @@
+import type { EnvTarget } from '../helpers';
+export type BaseSnapshotTarget = Readonly<{
+    env: EnvTarget;
+    siteId: string;
+}>;
+export type BaseSnapshotStoredTarget = Readonly<{
+    env: EnvTarget;
+    siteIdHash: string;
+}>;
+export type WriteBaseSnapshotsInput<TItem, TSnapshot> = Readonly<{
+    contentDir: string;
+    rootDir: string;
+    snapshotDir: string;
+    items: readonly TItem[];
+    toSnapshot(item: TItem): TSnapshot;
+    fileNameForSnapshot(snapshot: TSnapshot): string;
+    cleanupMissing?: boolean;
+}>;
+export type WriteBaseSnapshotsResult = Readonly<{
+    rootDir: string;
+    count: number;
+}>;
+export declare function baseSnapshotRoot(contentDir: string, baseKind: string): string;
+export declare function baseSnapshotStoredTarget(target: BaseSnapshotTarget): BaseSnapshotStoredTarget;
+export declare function siteScopedSnapshotDir(input: Readonly<{
+    rootDir: string;
+    target: BaseSnapshotTarget;
+    leafDir: string;
+}>): string;
+export declare function writeBaseSnapshots<TItem, TSnapshot>(input: WriteBaseSnapshotsInput<TItem, TSnapshot>): Promise<WriteBaseSnapshotsResult>;
+export declare function readBaseSnapshot<TSnapshot>(snapshotPath: string): Promise<TSnapshot | null>;
+export declare function encodeSnapshotPathPart(value: string): string;

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

@@ -0,0 +1,27 @@
+export type RemoteMergePlanCore<TDecision, TSummary> = Readonly<{
+    decisions: readonly TDecision[];
+    summary: TSummary;
+}>;
+export type RemoteMergePlanConfig<TSubject, TBaseSnapshot, TValue, TDecision, TSummary> = Readonly<{
+    subjects(): readonly TSubject[];
+    readBaseSnapshot(subject: TSubject): Promise<TBaseSnapshot | null>;
+    valueFromBaseSnapshot(snapshot: TBaseSnapshot): TValue | null;
+    localValue(subject: TSubject): TValue | null;
+    remoteValue(subject: TSubject): TValue | null;
+    planDecision(input: Readonly<{
+        subject: TSubject;
+        base: TValue | null;
+        local: TValue | null;
+        remote: TValue | null;
+    }>): TDecision;
+    summarize(decisions: readonly TDecision[]): TSummary;
+}>;
+export declare function buildRemoteMergePlanWithConfig<TSubject, TBaseSnapshot, TValue, TDecision, TSummary>(config: RemoteMergePlanConfig<TSubject, TBaseSnapshot, TValue, TDecision, TSummary>): Promise<RemoteMergePlanCore<TDecision, TSummary>>;
+export type DecisionSummaryKeyMap<TDecisionKind extends string, TSummary> = Readonly<Record<TDecisionKind, NumericKeys<TSummary>>>;
+type NumericKeys<TValue> = {
+    [TKey in keyof TValue]: TValue[TKey] extends number ? TKey : never;
+}[keyof TValue];
+export declare function summarizeMergeDecisions<TDecisionKind extends string, TDecision extends {
+    kind: TDecisionKind;
+}, TSummary>(decisions: readonly TDecision[], initialSummary: TSummary, summaryKeyByDecisionKind: DecisionSummaryKeyMap<TDecisionKind, TSummary>): TSummary;
+export {};