@riverbankcms/sdk 0.95.0 → 0.98.0

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

@@ -1 +1,18 @@
-export declare const InlineTextEditor: () => import("react").JSX.Element;
+import { type ElementType } from 'react';
+import { type InlineText } from '../../../blocks/src/index';
+import { type InlineTextEditorTone } from './FloatingToolbar';
+export type InlineTextEditorProps = {
+    value: InlineText;
+    onChange: (nextValue: InlineText, plainText: string) => void;
+    as?: ElementType;
+    id?: string;
+    className?: string;
+    placeholder?: string;
+    maxLength?: number;
+    ariaLabel?: string;
+    ariaDescribedBy?: string;
+    toolbarTone?: InlineTextEditorTone;
+    onFocus?: () => void;
+    onBlur?: () => void;
+};
+export declare function InlineTextEditor({ value, onChange, as: Comp, id, className, placeholder, maxLength, ariaLabel, ariaDescribedBy, toolbarTone, onFocus, onBlur, }: InlineTextEditorProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export declare function InlineTextEditorStyles(): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+import { type InlineText } from '../../../blocks/src/index';
+export declare function parseEditableInlineText(root: HTMLElement): InlineText;
+export declare function inlineTextToEditableHtml(value: InlineText): string;

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/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/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/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

@@ -1,7 +1,8 @@
 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 { 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[]>;
@@ -38,11 +39,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,11 +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;
@@ -21,6 +24,7 @@ export interface ScopePushContext {
     autoPullStale: boolean;
     skipMeta: boolean;
     humanDiff: boolean;
+    mediaPolicy: PushMediaPolicy;
 }
 export type PushScopeResultStatus = 'noop' | 'dry-run' | 'aborted' | 'failed' | 'pushed';
 export interface PushScopeItemError {
@@ -58,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/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/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-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/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/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/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>;