@riverbankcms/sdk 0.95.0 → 0.96.0

package/dist/_dts/editor/src/inline/presentation.d.ts

@@ -0,0 +1,48 @@
+import type { CSSProperties } from 'react';
+import { type InlineTextAccentTone, type InlineTextHighlightTone } from '../../../blocks/src/index';
+import type { InlineTextEditorTone } from './FloatingToolbar';
+type RgbaColor = Readonly<{
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}>;
+export type InlineTextTypographySnapshot = Pick<CSSProperties, 'fontFamily' | 'fontSize' | 'fontStyle' | 'fontWeight' | 'letterSpacing' | 'lineHeight' | 'textTransform'>;
+export type InlineTextSurface = Readonly<{
+    kind: 'block-solid';
+    color: string;
+    rgba: RgbaColor;
+}> | Readonly<{
+    kind: 'image-overlay';
+    color: string;
+    rgba: RgbaColor;
+}> | Readonly<{
+    kind: 'theme-fallback';
+    color: string;
+    rgba: RgbaColor;
+}> | Readonly<{
+    kind: 'toolbar-fallback';
+    color: string;
+    rgba: RgbaColor;
+}>;
+export type InlineTextPresentationContext = Readonly<{
+    surface: InlineTextSurface;
+    selectedTextColor: string;
+    selectedTextRgba: RgbaColor;
+    accentTextRgbaByTone: Readonly<Record<InlineTextAccentTone, RgbaColor | null>>;
+    typography: InlineTextTypographySnapshot;
+}>;
+export type InlineTextTonePreview = Readonly<{
+    surfaceStyle: CSSProperties;
+    textStyle: CSSProperties;
+    surfaceRgba: RgbaColor;
+    textRgba: RgbaColor;
+    lowContrast: boolean;
+}>;
+export declare function defaultInlineTextPresentationContext(tone: InlineTextEditorTone): InlineTextPresentationContext;
+export declare function readInlineTextPresentationContext(editable: HTMLElement, toolbarTone: InlineTextEditorTone): InlineTextPresentationContext;
+export declare function buildAccentTonePreview(tone: InlineTextAccentTone, context: InlineTextPresentationContext): InlineTextTonePreview;
+export declare function buildHighlightTonePreview(tone: InlineTextHighlightTone, context: InlineTextPresentationContext): InlineTextTonePreview;
+export declare function buildPlainTonePreview(context: InlineTextPresentationContext): InlineTextTonePreview;
+export declare function inlineTextTonePreviewLooksSame(left: InlineTextTonePreview, right: InlineTextTonePreview): boolean;
+export {};

package/dist/_dts/editor/src/inline/selection.d.ts

@@ -0,0 +1,12 @@
+import { type InlineText, type InlineTextMark } from '../../../blocks/src/index';
+export type InlineTextSelection = Readonly<{
+    start: number;
+    end: number;
+    rect: DOMRect;
+}>;
+export declare function readSelection(root: HTMLElement | null): InlineTextSelection | null;
+export declare function readSelectionRange(root: HTMLElement | null): InlineTextSelection | null;
+export declare function rangeHasMark(value: InlineText, range: Readonly<{
+    start: number;
+    end: number;
+}>, kind: InlineTextMark['kind']): boolean;

package/dist/_dts/editor-blocks/src/widgets/index.d.ts

@@ -2,6 +2,7 @@ export * from './button/index';
 export * from './content-type-select/index';
 export * from './entry-picker/index';
 export * from './icon-picker/index';
+export * from './inline-text/index';
 export * from './link/index';
 export * from './offerings-preview/index';
 export * from './reference/index';

package/dist/_dts/editor-blocks/src/widgets/inline-text/InlineTextField.d.ts

@@ -0,0 +1,3 @@
+import type { FieldWidgetProps, InlineTextFieldConfig } from '../../../../block-form/src/client/index';
+import { type InlineText } from '../../../../blocks/src/index';
+export declare function InlineTextField({ path, backend, config, }: FieldWidgetProps<InlineText, InlineTextFieldConfig>): import("react").JSX.Element;

package/dist/_dts/editor-blocks/src/widgets/inline-text/index.d.ts

@@ -0,0 +1 @@
+export { InlineTextField } from './InlineTextField';

package/dist/_dts/path-utils/src/index.d.ts

@@ -1,6 +1,7 @@
 export type PathSegment = string | number;
 export declare function parsePath(path: string | Array<PathSegment>): Array<PathSegment>;
 export declare function segmentsToPath(segments: Array<PathSegment>): string | undefined;
+export declare function siblingPath(path: string, siblingFieldPath: string): string;
 export declare function getAtPath<T = unknown>(source: unknown, path: string | Array<PathSegment>): T | undefined;
 export declare function setAtPath(target: Record<string, unknown> | Array<unknown>, path: string | Array<PathSegment>, value: unknown): void;
 export declare function toAbsolutePath(base: string | undefined | null, path: string): string;

package/dist/_dts/preview-next/src/client/widgets/widgetOverrides.d.ts

@@ -20,6 +20,7 @@ export declare const previewWidgetOverrides: {
     readonly file: FieldWidgetComponent;
     readonly media: FieldWidgetComponent;
     readonly richText: FieldWidgetComponent;
+    readonly inlineText: FieldWidgetComponent;
     readonly reference: FieldWidgetComponent;
     readonly backgroundColor: FieldWidgetComponent;
     readonly backgroundGradient: FieldWidgetComponent;

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

@@ -0,0 +1,56 @@
+import { Command } from 'commander';
+import { type ContentEditOperation, type ContentEditPlan, type PageBlockMoveTarget } from '../content/edit/planner';
+import { type OutputContext } from '../output';
+type CommonEditOptions = Readonly<{
+    contentDir?: string;
+    write?: boolean;
+}>;
+type FieldSetOptions = CommonEditOptions & Readonly<{
+    value?: string;
+    jsonValue?: string;
+}>;
+type MoveBlockOptions = CommonEditOptions & Readonly<{
+    before?: string;
+    after?: string;
+    toStart?: boolean;
+    toEnd?: boolean;
+}>;
+export type RunContentEditErrorCode = 'missing_file' | 'invalid_json' | 'read_failed';
+export type RunContentEditError = Readonly<{
+    code: RunContentEditErrorCode;
+    message: string;
+}>;
+export type RunContentEditResult = Readonly<{
+    success: true;
+    plan: ContentEditPlan;
+    filePath: string;
+    written: boolean;
+}> | Readonly<{
+    success: false;
+    plan?: ContentEditPlan;
+    filePath: string;
+    written: false;
+    error?: RunContentEditError;
+}>;
+export declare function runPageContentEdit(input: Readonly<{
+    operation: ContentEditOperation;
+    contentDir?: string;
+    write: boolean;
+    output: OutputContext;
+}>): Promise<RunContentEditResult>;
+export declare function parseContentEditValue(options: FieldSetOptions): Readonly<{
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function parseMoveTarget(options: MoveBlockOptions): Readonly<{
+    ok: true;
+    target: PageBlockMoveTarget;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare const contentCommand: Command;
+export {};

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

@@ -22,4 +22,8 @@ export interface PushOptions {
     meta?: boolean;
     /** Show human-readable field-level diff (requires --dry-run) */
     diff?: boolean;
+    /** Re-fetch after an applied push and fail if changes remain */
+    verifyNoop?: boolean;
+    /** Continue event scoped pushes when local media identifiers are missing */
+    allowMissingMedia?: boolean;
 }

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

@@ -1,5 +1,5 @@
 import type { SiteId } from '../../../../../../core/src/index';
-import { type JsonDiffMode } from '../../../sync';
+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 { PushScopeResult, ScopePushContext } from './types';
@@ -38,11 +38,7 @@ export type DatedOfferingDryRunItem = Readonly<{
     identifier: string;
     label: string;
     status: DatedOfferingDryRunItemStatus;
-    changes: readonly Readonly<{
-        path: string;
-        before: unknown;
-        after: unknown;
-    }>[];
+    changes: readonly FieldChange[];
 }>;
 export type DatedOfferingDryRunSummary = Readonly<{
     created: number;

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

@@ -5,6 +5,7 @@ import type { SiteId } from '../../../../../../core/src/index';
 import type { EnvTarget } from '../../../helpers';
 import type { JsonDiffMode } from '../../../sync';
 import type { LocalMediaPushReport } from '../../../media/local-sync';
+export type PushMediaPolicy = 'require' | 'allow-missing';
 export interface ScopePushContext {
     output: OutputContext;
     contentDir: string;
@@ -21,6 +22,7 @@ export interface ScopePushContext {
     autoPullStale: boolean;
     skipMeta: boolean;
     humanDiff: boolean;
+    mediaPolicy: PushMediaPolicy;
 }
 export type PushScopeResultStatus = 'noop' | 'dry-run' | 'aborted' | 'failed' | 'pushed';
 export interface PushScopeItemError {

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

@@ -0,0 +1,56 @@
+import type { EnvTarget } from '../../helpers';
+import type { OutputContext } from '../../output';
+import type { PushOptions } from './options';
+import { type PushScope } from './consts';
+export type PushVerificationStatus = 'clean' | 'dirty' | 'fetch_failed' | 'unsupported_scope';
+export type PushVerificationDirtyScope = Readonly<{
+    scope: string;
+    summary: Readonly<Record<string, number>>;
+}>;
+export type PushVerificationResult = Readonly<{
+    status: 'clean';
+    target: EnvTarget;
+}> | Readonly<{
+    status: 'dirty';
+    target: EnvTarget;
+    dirtyScopes: readonly PushVerificationDirtyScope[];
+}> | Readonly<{
+    status: 'fetch_failed';
+    target: EnvTarget;
+    error: string;
+}> | Readonly<{
+    status: 'unsupported_scope';
+    target: EnvTarget;
+    scope: string;
+}>;
+export type PushVerificationInput = Readonly<{
+    target: EnvTarget;
+    scope: string | undefined;
+    type: string | undefined;
+    identifier: string | undefined;
+    options: PushOptions;
+}>;
+export type PushVerificationDeps = Readonly<{
+    verifyGeneric: (input: PushVerificationInput & {
+        pushScope: PushScope;
+    }) => Promise<readonly PushVerificationDirtyScope[]>;
+    verifyDatedOffering: (input: PushVerificationInput & {
+        pushScope: 'venues' | 'event-categories' | 'events' | 'courses';
+    }) => Promise<readonly PushVerificationDirtyScope[]>;
+}>;
+export declare function collectDatedOfferingVerificationOrphans<TLocal, TRemote>(input: Readonly<{
+    deleteOrphaned: boolean;
+    hasScopedSelector: boolean;
+    allLocalItems: readonly TLocal[];
+    remoteItems: readonly TRemote[];
+    getLocalIdentifier: (item: TLocal) => string;
+    getRemoteIdentifier: (item: TRemote) => string;
+}>): readonly string[];
+export declare function verifyGenericPushNoop(input: PushVerificationInput & {
+    pushScope: PushScope;
+}): Promise<readonly PushVerificationDirtyScope[]>;
+export declare function createProductionPushVerificationDeps(): PushVerificationDeps;
+export declare function verifyPushNoopForEnvWithDeps(deps: PushVerificationDeps, input: PushVerificationInput): Promise<PushVerificationResult>;
+export declare function verifyPushNoopForEnv(input: PushVerificationInput): Promise<PushVerificationResult>;
+export declare function isPushVerificationClean(result: PushVerificationResult): boolean;
+export declare function emitPushVerificationResult(output: OutputContext, result: PushVerificationResult, jsonOutput: boolean): void;

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

@@ -28,7 +28,8 @@ type MergeRemoteValidationError = Readonly<{
         suggestion: string;
     }>;
 }>;
-export declare function validateMergeRemoteEntryPushOptions(input: MergeRemoteValidationInput): MergeRemoteValidationError | null;
+export declare function validateMergeRemotePushOptions(input: MergeRemoteValidationInput): MergeRemoteValidationError | null;
+export declare const validateMergeRemoteEntryPushOptions: typeof validateMergeRemotePushOptions;
 /**
  * Execute push for a single environment.
  * Extracted to support --env=both multi-environment operations.

package/dist/_dts/sdk/src/cli/content/edit/format.d.ts

@@ -0,0 +1,2 @@
+import type { ContentEditPlan } from './planner';
+export declare function formatContentEditPlan(plan: ContentEditPlan): readonly string[];

package/dist/_dts/sdk/src/cli/content/edit/path.d.ts

@@ -0,0 +1,14 @@
+import { type FieldPathSegment } from '../../sync/field-diff';
+export type ContentFieldPathSegment = Extract<FieldPathSegment, Readonly<{
+    type: 'property' | 'index';
+}>>;
+export type ContentFieldPath = readonly ContentFieldPathSegment[];
+export type ParseContentFieldPathResult = Readonly<{
+    ok: true;
+    path: ContentFieldPath;
+}> | Readonly<{
+    ok: false;
+    error: string;
+}>;
+export declare function parseContentFieldPath(value: string): ParseContentFieldPathResult;
+export declare function formatContentFieldPath(path: ContentFieldPath): string;

package/dist/_dts/sdk/src/cli/content/edit/planner.d.ts

@@ -0,0 +1,46 @@
+import type { LocalPage } from '../reader';
+import { type FieldChange } from '../../sync/field-diff';
+import { type ContentFieldPath } from './path';
+export type PageBlockMoveTarget = Readonly<{
+    tag: 'to_start';
+}> | Readonly<{
+    tag: 'to_end';
+}> | Readonly<{
+    tag: 'before';
+    blockIdentifier: string;
+}> | Readonly<{
+    tag: 'after';
+    blockIdentifier: string;
+}>;
+export type ContentEditOperation = Readonly<{
+    tag: 'remove_page_block';
+    pageIdentifier: string;
+    blockIdentifier: string;
+}> | Readonly<{
+    tag: 'move_page_block';
+    pageIdentifier: string;
+    blockIdentifier: string;
+    target: PageBlockMoveTarget;
+}> | Readonly<{
+    tag: 'update_page_field';
+    pageIdentifier: string;
+    path: ContentFieldPath;
+    value: unknown;
+}>;
+export type ContentEditErrorCode = 'wrong_page' | 'missing_blocks' | 'missing_block' | 'duplicate_block_identifier' | 'missing_move_target' | 'move_target_is_source' | 'invalid_field_path' | 'noop';
+export type ContentEditError = Readonly<{
+    code: ContentEditErrorCode;
+    message: string;
+}>;
+export type ContentEditPlan = Readonly<{
+    tag: 'will_change';
+    operation: ContentEditOperation;
+    before: LocalPage;
+    after: LocalPage;
+    changes: readonly FieldChange[];
+}> | Readonly<{
+    tag: 'invalid';
+    operation: ContentEditOperation;
+    error: ContentEditError;
+}>;
+export declare function planPageContentEdit(page: LocalPage, operation: ContentEditOperation): ContentEditPlan;

package/dist/_dts/sdk/src/cli/content/fs-utils.d.ts

@@ -29,6 +29,10 @@ export declare function readJsonFile<T>(filePath: string): Promise<T>;
  * Write JSON file with pretty formatting
  */
 export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;
+/**
+ * Write JSON file via a same-directory temp file and atomic rename.
+ */
+export declare function writeJsonFileAtomic(filePath: string, data: unknown): Promise<void>;
 /**
  * Ensure directory exists, creating it if necessary
  */

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

@@ -7,10 +7,12 @@ import type { PulledEntries, PulledPages, PulledNavigation, PulledSettings, Pull
 import type { Theme } from '../../contracts';
 import { type PulledEntryOutput } from '../helpers';
 import type { EntryBaseSnapshotTarget } from '../merge-remote/entrySnapshots';
+import type { PageBaseSnapshotTarget } from '../merge-remote/pageSnapshots';
 export interface WriterOptions {
     skipMeta?: boolean;
     cleanupMissing?: boolean;
     entryBaseSnapshot?: EntryBaseSnapshotTarget;
+    pageBaseSnapshot?: PageBaseSnapshotTarget;
 }
 type WritablePulledEntries = Omit<PulledEntries, 'entries'> & {
     entries: PulledEntryOutput[];

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

@@ -0,0 +1,22 @@
+export type ScalarMergeChangeValue = string | number | boolean | null | undefined;
+export type MergeChange = Readonly<{
+    path: string;
+}> & (Readonly<{
+    value: ScalarMergeChangeValue;
+    containerKind: 'scalar' | 'null';
+}> | Readonly<{
+    value: Record<string, unknown>;
+    containerKind: 'object';
+}> | Readonly<{
+    value: readonly unknown[];
+    containerKind: 'array';
+}>);
+export type ScalarMergeChange = Extract<MergeChange, {
+    containerKind: 'scalar' | 'null';
+}>;
+export declare function collectMergeChanges(currentPath: string, base: unknown, next: unknown, changes: Map<string, MergeChange>): void;
+export declare function firstNestedContainerChange<TChange extends MergeChange>(localChanges: ReadonlyMap<string, TChange>, remoteChanges: ReadonlyMap<string, TChange>): TChange | null;
+export declare function firstSameFieldConflictPath(localChanges: ReadonlyMap<string, MergeChange>, remoteChanges: ReadonlyMap<string, MergeChange>): string | null;
+export declare function scalarMergeChanges<TChange extends MergeChange>(changes: ReadonlyMap<string, TChange>, label: string): readonly Extract<TChange, {
+    containerKind: 'scalar' | 'null';
+}>[];

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

@@ -0,0 +1,3 @@
+import type { PulledPages } from '../../client/management/types';
+import type { LocalPage } from '../content/reader';
+export declare function pulledPageToLocalPage(page: PulledPages['pages'][number]): LocalPage;

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

@@ -0,0 +1,78 @@
+import type { LocalPage } from '../content/reader';
+export type PageMergeSubject = Readonly<{
+    identifier: string;
+}>;
+export type PageMergeInputs = Readonly<{
+    subject: PageMergeSubject;
+    base: LocalPage | null;
+    local: LocalPage | null;
+    remote: LocalPage | null;
+}>;
+export type PageMergeConflict = Readonly<{
+    code: 'missing_base';
+    subject: PageMergeSubject;
+    message: string;
+}> | Readonly<{
+    code: 'same_field_changed';
+    subject: PageMergeSubject;
+    fieldPath: string;
+    message: string;
+}> | Readonly<{
+    code: 'local_delete_unsupported';
+    subject: PageMergeSubject;
+    message: string;
+}> | Readonly<{
+    code: 'remote_delete_local_edit';
+    subject: PageMergeSubject;
+    message: string;
+}> | Readonly<{
+    code: 'unsupported_nested_merge';
+    subject: PageMergeSubject;
+    fieldPath: string;
+    message: string;
+}>;
+export type PageMergeDecision = Readonly<{
+    kind: 'unchanged';
+    subject: PageMergeSubject;
+    desired: LocalPage | null;
+}> | Readonly<{
+    kind: 'bootstrap_base';
+    subject: PageMergeSubject;
+    desired: LocalPage;
+}> | Readonly<{
+    kind: 'preserve_remote';
+    subject: PageMergeSubject;
+    desired: LocalPage | null;
+}> | Readonly<{
+    kind: 'apply_local_create' | 'apply_local_update';
+    subject: PageMergeSubject;
+    desired: LocalPage;
+}> | Readonly<{
+    kind: 'auto_merge';
+    subject: PageMergeSubject;
+    desired: LocalPage;
+    localFieldPaths: readonly string[];
+    remoteFieldPaths: readonly string[];
+}> | Readonly<{
+    kind: 'conflict';
+    subject: PageMergeSubject;
+    conflict: PageMergeConflict;
+}>;
+export type ComparablePage = Readonly<{
+    identifier: string;
+    title: string;
+    path: string;
+    status?: LocalPage['status'];
+    hasUnpublishedChanges?: boolean;
+    seoTitle?: string;
+    seoDescription?: string;
+    blocks?: ReadonlyArray<Readonly<{
+        identifier: string;
+        kind: string;
+        position?: number;
+        data: Readonly<Record<string, unknown>>;
+    }>>;
+}>;
+export declare function planPageMerge(input: PageMergeInputs): PageMergeDecision;
+export declare function comparablePage(page: LocalPage | null): ComparablePage | null;
+export declare function pagesEqual(left: LocalPage | null, right: LocalPage | null): boolean;

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

@@ -0,0 +1,36 @@
+import type { PulledPages } from '../../client/management/types';
+import type { LocalPage } from '../content/reader';
+import { type PageMergeDecision } from './pageMerge';
+import { type PageBaseSnapshotTarget } from './pageSnapshots';
+export type PageMergePushScope = Readonly<{
+    kind: 'all_pages';
+}> | Readonly<{
+    kind: 'single_page';
+    identifier: string;
+}>;
+export type RemotePageMergePlan = Readonly<{
+    scope: PageMergePushScope;
+    decisions: readonly PageMergeDecision[];
+    summary: RemotePageMergePlanSummary;
+}>;
+export type RemotePageMergePlanSummary = Readonly<{
+    unchanged: number;
+    bootstrapBase: number;
+    preserveRemote: number;
+    applyLocalCreate: number;
+    applyLocalUpdate: number;
+    autoMerge: number;
+    conflicts: number;
+}>;
+export type RemotePageMergePlanInput = Readonly<{
+    contentDir: string;
+    target: PageBaseSnapshotTarget;
+    scope: PageMergePushScope;
+    localPages: readonly LocalPage[];
+    remotePages: readonly PulledPages['pages'][number][];
+}>;
+export declare function buildRemotePageMergePlan(input: RemotePageMergePlanInput): Promise<RemotePageMergePlan>;
+export declare function summarizePageMergeDecisions(decisions: readonly PageMergeDecision[]): RemotePageMergePlanSummary;
+export declare function pageMergePushScope(input: Readonly<{
+    identifier?: string;
+}>): PageMergePushScope;

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

@@ -0,0 +1,21 @@
+import type { SiteId } from '../../../../core/src/index';
+import type { ManagementClient } from '../../client/management/types';
+import type { LocalPage } from '../content/reader';
+import type { EnvTarget } from '../helpers';
+import type { OutputContext } from '../output';
+export type RemotePageMergePushResult = Readonly<{
+    success: boolean;
+}>;
+export declare function planAndReportRemotePageMerge(input: Readonly<{
+    output: OutputContext;
+    client: Pick<ManagementClient, 'pages' | 'blocks' | 'pull'>;
+    contentDir: string;
+    target: EnvTarget;
+    siteId: SiteId;
+    identifier?: string;
+    localPages: readonly LocalPage[];
+    dryRun: boolean;
+    jsonOutput: boolean;
+    jsonDiff: boolean;
+    skipMeta: boolean;
+}>): Promise<RemotePageMergePushResult>;

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

@@ -0,0 +1,29 @@
+import type { OutputContext } from '../output';
+import type { PageMergeConflict, 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'];
+    identifier: string;
+    localFieldPaths?: readonly string[];
+    remoteFieldPaths?: readonly string[];
+    conflict?: Readonly<{
+        code: PageMergeConflict['code'];
+        fieldPath?: string;
+        message: string;
+    }>;
+}>;
+export declare function remotePageMergeJsonReport(input: Readonly<{
+    plan: RemotePageMergePlan;
+    dryRun: boolean;
+}>): RemotePageMergeJsonReport;
+export declare function writeRemotePageMergeHumanReport(output: Pick<OutputContext, 'info'>, plan: RemotePageMergePlan, options: Readonly<{
+    dryRun: boolean;
+}>): void;

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

@@ -0,0 +1,48 @@
+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;
+}>;
+export type PageBaseSnapshotSubject = Readonly<{
+    identifier: string;
+}>;
+export type PageBaseSnapshot = Readonly<{
+    version: 'page-base.v1';
+    target: Readonly<{
+        env: EnvTarget;
+        siteIdHash: string;
+    }>;
+    subject: PageBaseSnapshotSubject;
+    pulledAt: string;
+    remoteVersion: Readonly<{
+        createdAt?: string;
+        updatedAt?: string;
+        publishedAt?: string | null;
+    }>;
+    page: LocalPage;
+}>;
+export type WritePageBaseSnapshotsInput = Readonly<{
+    contentDir: string;
+    target: PageBaseSnapshotTarget;
+    pages: PulledPages['pages'];
+    meta: PulledPages['meta'];
+    cleanupMissing?: boolean;
+}>;
+export type WritePageBaseSnapshotsResult = Readonly<{
+    rootDir: string;
+    count: number;
+}>;
+export declare function pageBaseSnapshotRoot(contentDir: string): string;
+export declare function pageBaseSnapshotPath(input: Readonly<{
+    contentDir: string;
+    target: PageBaseSnapshotTarget;
+    subject: PageBaseSnapshotSubject;
+}>): string;
+export declare function writePageBaseSnapshots(input: WritePageBaseSnapshotsInput): Promise<WritePageBaseSnapshotsResult>;
+export declare function readPageBaseSnapshot(input: Readonly<{
+    contentDir: string;
+    target: PageBaseSnapshotTarget;
+    subject: PageBaseSnapshotSubject;
+}>): Promise<PageBaseSnapshot | null>;

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

@@ -6,6 +6,8 @@
  */
 import type { LocalContent, LocalFooterContent } from '../content/reader';
 import type { PulledContent, ManagementFooterContent } from '../../client/management/types';
+import { type BuildFieldDiffOptions, type FieldChange } from './field-diff';
+export type { FieldChange } from './field-diff';
 export type DiffType = 'create' | 'update' | 'unchanged';
 export interface EntryDiff {
     type: DiffType | 'delete';
@@ -205,15 +207,10 @@ export declare function formatDiffDetail(diff: ContentDiff): string;
  * @returns Content diff showing what would be created/updated locally
  */
 export declare function calculatePullDiff(remote: PulledContent, local: LocalContent | null): ContentDiff;
-export interface FieldChange {
-    path: string;
-    before: unknown;
-    after: unknown;
-}
 /**
  * Find changed fields between two objects with their before/after values.
  */
-export declare function findChangedFieldsWithValues(local: Record<string, unknown>, remote: Record<string, unknown>, prefix?: string): FieldChange[];
+export declare function findChangedFieldsWithValues(local: Record<string, unknown>, remote: Record<string, unknown>, prefix?: string, options?: BuildFieldDiffOptions): FieldChange[];
 /**
  * Format a value for human-readable display.
  */