@riverbankcms/sdk 0.62.4 → 0.67.0

package/dist/_dts/api/src/types.d.ts

@@ -3,6 +3,7 @@ export type { AccessPolicyContract, AccessPolicyTag, CreateMediaAssetBody, Entit
 export type { AnalyticsPreset, AnalyticsReferrer, AnalyticsReportFilters, AnalyticsReportQuery, AnalyticsReportResponse, AnalyticsSeriesPoint, AnalyticsTopPage, AnalyticsTotals, } from "./analytics";
 export type { AIChatMessage, AiBriefTurn, JsonPrimitive, JsonValue, MediaUsageCheckItem, MediaUsageCheckResponse, MediaUsageLocation, } from "./shared-contracts";
 export type * from "./accessAdmin";
+export { STAFF_OPERATIONAL_CAPABILITIES } from "./accessAdmin";
 export type * from "./aiEndpoints";
 export type * from "./apiEndpointTypes";
 export type * from "./bookingAdjustments";
@@ -42,7 +43,7 @@ export type { SitePageBlock, SitePagePayload } from "./sitePages";
 export type { SiteAnalyticsCookieBannerCopyOverrides, SiteAnalyticsSettingsPayload, SiteAnalyticsSettingsResponse, } from "./siteAnalytics";
 export type { SiteLegalJurisdiction, SiteLegalProfilePayload, SensitiveClientRecordsConfirmationKey, SensitiveClientRecordsMode, SensitiveClientRecordsRetentionProfile, SensitiveClientRecordsSettings, SensitiveClientRecordsUpdatePayload, SitePrivacyPolicyCapabilities, SitePrivacyPolicyDocument, SitePrivacySettings, SitePrivacySettingsPayload, SitePrivacySettingsResponse, SiteRuntimePrivacyPolicy, SitePrivacyPolicySection, } from "./privacyPolicy";
 export type { MaintenanceSettingsPayload, MaintenanceSettingsResponse, SiteBusinessAddressPayload, SiteBusinessAddressResponse, SiteDeploymentMode, SiteFooterBlocksEditorBlock, SiteFooterBlocksEditorResponse, SiteGeneralSettingsPayload, SiteGeneralSettingsResponse, SiteLayoutResolvedPayload, SiteLayoutSettingsPayload, SiteLayoutSettingsResponse, UpdateSiteDeploymentModePayload, UpdateSiteDeploymentModeResponse, UpdateSiteFooterBlocksPayload, UpdateSiteFooterBlocksResponse, } from "./siteSettings";
-export type { BillingCheckoutRequest, BillingCheckoutResponse, BillingStatusResponse, BillingSummaryResponse, SiteBillingCheckoutResponse, SiteBillingCostResponse, StripeAutomaticTaxIssue, StripeAutomaticTaxReadiness, StripeAutomaticTaxStatus, StripeConnectDisconnectResponse, StripeConnectRestrictions, StripeConnectStartResponse, StripeConnectStatusResponse, UpdateStripeAutomaticTaxRequest, } from "./billing";
+export type { BillingCheckoutRequest, BillingCheckoutResponse, BillingStatusResponse, BillingSummaryComponent, BillingSummaryComponentKind, BillingSummaryComponentSource, BillingSummaryBasePlanComponent, BillingSummarySiteComponent, BillingSummaryAddOnComponent, BillingSummaryResponse, SiteBillingCheckoutResponse, SiteBillingCostResponse, StripeAutomaticTaxIssue, StripeAutomaticTaxReadiness, StripeAutomaticTaxStatus, StripeConnectDisconnectResponse, StripeConnectRestrictions, StripeConnectStartResponse, StripeConnectStatusResponse, UpdateStripeAutomaticTaxRequest, } from "./billing";
 export type { AiGenerateSiteEntityType, AiGenerateSitePrimaryCta, AiGenerateSiteRequest, AiGenerateSiteResponse, } from "./siteGeneration";
 export { SITE_ROLE_DISPLAY_ORDER, SITE_ROLE_PERMISSION_LEVEL } from "./siteMembers";
 export type { SiteRole } from "./siteMembers";

package/dist/_dts/billing/src/plans/registry.d.ts

@@ -5,6 +5,7 @@ export declare function ensureBillingPlanId(planId: string): BillingPlanId;
 export declare function getPlanById(planId: string): PlanDefinition | undefined;
 export declare function ensurePlan(planId: string): PlanDefinition;
 export declare function getPlanEntitlements(planId: string): PlanDefinition['entitlements'];
+export declare function getMacadamiaSiteAllowance(planId: string): PlanDefinition['entitlements']['macadamiaSiteAllowance'];
 /**
  * @deprecated Use database pricing with resolveUserPrice() instead.
  * This function fetches pre-created Stripe Price IDs which is being replaced

package/dist/_dts/billing/src/plans/types.d.ts

@@ -40,7 +40,7 @@ export declare const BRANDING_TIERS: readonly ["macadamia_visible", "light_custo
 export type BrandingTier = (typeof BRANDING_TIERS)[number];
 export declare const TEAM_TIERS: readonly ["owner_only", "multi_practitioner"];
 export type TeamTier = (typeof TEAM_TIERS)[number];
-export declare const SITE_ROLE_ENTITLEMENTS: readonly ["administrator", "editor", "event_host", "team_member"];
+export declare const SITE_ROLE_ENTITLEMENTS: readonly ["administrator", "editor", "team_member"];
 export type SiteRoleEntitlement = (typeof SITE_ROLE_ENTITLEMENTS)[number];
 export declare const PLAN_BOOLEAN_FEATURE_KEYS: readonly ["customDomain", "customContentTypes", "analytics", "passes", "memberships", "discountCodes", "advancedPaymentSchemes", "internalNotes", "multipleTeamLogins", "multiplePractitioners"];
 export type PlanBooleanFeatureKey = (typeof PLAN_BOOLEAN_FEATURE_KEYS)[number];
@@ -55,6 +55,15 @@ export interface PlanEntitlements {
     planId: BillingPlanId;
     monthlyPricePence: number | null;
     availableIntervals: readonly BillingInterval[];
+    macadamiaSiteAllowance: Readonly<{
+        includedLiveSiteCount: number;
+        extraSite: Readonly<{
+            tag: 'not_supported';
+        }> | Readonly<{
+            tag: 'priced';
+            monthlyPricePence: number;
+        }>;
+    }>;
     monthlyBookingLimit: number | null;
     durableStorageQuota: StorageQuota;
     stripeBookingCommission: StripeBookingCommission;

package/dist/_dts/block-form/src/FormRenderer.d.ts

@@ -0,0 +1,38 @@
+/**
+ * FormRenderer - Generic form rendering component
+ *
+ * Completely manifest-agnostic. Renders any FieldConfig[] with any FormBackend.
+ * Provides renderChild recursively for container widgets (GroupField, RepeaterField).
+ */
+import type { ReactNode } from 'react';
+import type { FieldConfig } from './fields/types';
+import type { FormBackend } from './backend/types';
+import type { FieldWidgetComponent } from './fields/props';
+export interface FormRendererProps {
+    /** Field configurations to render */
+    fields: FieldConfig[];
+    /** Form backend (RHF or Store) */
+    backend: FormBackend;
+    /** Optional className for container */
+    className?: string;
+    /** Optional wrapper component for each field */
+    fieldWrapper?: (children: ReactNode, field: FieldConfig) => ReactNode;
+    /** Optional widget overrides - allows replacing widgets at runtime */
+    widgetOverrides?: Partial<Record<string, FieldWidgetComponent>>;
+    /** Optional block kind for SDK field options lookup (e.g., 'block.embed', 'custom.hero') */
+    blockKind?: string;
+    /** Show inline settings trigger for non-content intents (default: true) */
+    showSettingsTrigger?: boolean;
+    /**
+     * Optional list of nested field paths to surface in the main form body as shortcuts.
+     * These paths should refer to existing data within the form values (no duplication).
+     */
+    promotedFields?: string[];
+}
+/**
+ * FormRenderer - Renders a list of fields using the widget registry
+ *
+ * Works with any field source (manifests, custom configs, etc.)
+ * Works with any backend (RHF, Zustand store, etc.)
+ */
+export declare function FormRenderer({ fields, backend, className, fieldWrapper, widgetOverrides, blockKind, showSettingsTrigger, promotedFields, }: FormRendererProps): ReactNode;

package/dist/_dts/block-form/src/backend/adapter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @deprecated Import from './types', './rhf-backend', or './store-backend' instead.
+ * This file is kept for backward compatibility only.
+ */
+export type { FormBackend, SetValueOptions, FieldError, FieldState, FormState, StoreBackendOptions, } from './types';
+export { createRHFBackend } from './rhf-backend';
+export { createStoreBackend } from './store-backend';

package/dist/_dts/block-form/src/backend/hooks/useRepeaterBackend.d.ts

@@ -0,0 +1,34 @@
+import type { FormBackend } from '../adapter';
+/**
+ * Item with stable React key for repeater rendering
+ */
+export type RepeaterItem = {
+    /** Stable ID for React keys and drag-drop */
+    id: string;
+    /** Item data */
+    data: unknown;
+};
+/**
+ * Array operations interface for repeater widgets
+ */
+export type RepeaterBackendOps = {
+    /** Array items with stable keys */
+    items: RepeaterItem[];
+    /** Append item to array */
+    append: (value: unknown) => void;
+    /** Remove item at index */
+    remove: (index: number) => void;
+    /** Move item from one index to another */
+    move: (from: number, to: number) => void;
+    /** Insert item at index */
+    insert: (index: number, value: unknown) => void;
+};
+/**
+ * Hook to get repeater operations from a backend.
+ * Provides stable keys for React rendering and drag-drop.
+ *
+ * Uses backend's unified interface throughout - no branching on backend.type.
+ * For RHF backends, uses react-hook-form's optimized useFieldArray hook.
+ * For other backends, uses useSyncExternalStore with the backend's subscribe/getValue.
+ */
+export declare function useRepeaterBackend(backend: FormBackend, path: string): RepeaterBackendOps;

package/dist/_dts/block-form/src/backend/hooks.d.ts

@@ -0,0 +1,66 @@
+import type { FormBackend, SetValueOptions } from './types';
+/**
+ * useArrayField - Hook for array field operations (append, remove, move, insert)
+ *
+ * @param path - Field path
+ * @param backend - Form backend
+ * @returns Object with array manipulation functions
+ */
+export declare function useArrayField(path: string, backend: FormBackend): {
+    append: (value: unknown) => void;
+    remove: (index: number) => void;
+    move: (from: number, to: number) => void;
+    insert: (index: number, value: unknown) => void;
+};
+/**
+ * useField - Combined hook for field value, state, and setter
+ *
+ * This is the recommended hook for form widgets. It provides everything needed
+ * for a field in one call, using the unified backend.subscribe API.
+ *
+ * No branching on backend.type - the backend hides implementation details.
+ *
+ * @example
+ * ```tsx
+ * function TextField({ path, backend, field }: FormFieldProps<string>) {
+ *   const { value, error, isDirty, setValue } = useField<string>(path, backend)
+ *
+ *   return (
+ *     <input
+ *       value={value ?? ''}
+ *       onChange={(e) => setValue(e.target.value)}
+ *     />
+ *   )
+ * }
+ * ```
+ */
+export declare function useField<T = unknown>(path: string, backend: FormBackend): {
+    value: T | undefined;
+    error: import("./types").FieldError | undefined;
+    isDirty: boolean | undefined;
+    isTouched: boolean | undefined;
+    invalid: boolean | undefined;
+    setValue: (newValue: T, options?: SetValueOptions) => void;
+};
+/**
+ * useFieldError - Hook to get only the error state of a field
+ *
+ * Use this for container widgets (GroupField, RepeaterField) that need to display
+ * group-level errors but don't interact with the field value.
+ *
+ * More efficient than useField when you only need error state.
+ *
+ * @example
+ * ```tsx
+ * function GroupField({ path, backend, field, renderChild }: FormFieldProps) {
+ *   const error = useFieldError(path, backend)
+ *
+ *   return (
+ *     <FieldFrame error={error?.message}>
+ *       {field.fields.map(child => renderChild(child, `${path}.${child.id}`))}
+ *     </FieldFrame>
+ *   )
+ * }
+ * ```
+ */
+export declare function useFieldError(path: string, backend: FormBackend): import("./types").FieldError | undefined;

package/dist/_dts/block-form/src/backend/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Backend abstraction layer for form operations
+ *
+ * This module provides a unified API that works with either:
+ * - React Hook Form (RHF) for traditional form handling
+ * - Zustand Store for inline editing with autosave
+ */
+export * from './types';
+export * from './hooks';
+export * from './adapter';
+export { useRepeaterBackend } from './hooks/useRepeaterBackend';
+export type { RepeaterBackendOps, RepeaterItem } from './hooks/useRepeaterBackend';

package/dist/_dts/block-form/src/backend/rhf-backend.d.ts

@@ -0,0 +1,34 @@
+/**
+ * React Hook Form (RHF) backend implementation
+ *
+ * Wraps a react-hook-form instance to provide the unified FormBackend interface.
+ * Validation is handled by the resolver passed to useForm (e.g., zodResolver).
+ *
+ * ## Why `as never` casts are used
+ *
+ * React Hook Form is heavily typed around its generic parameter, so methods like
+ * `setValue<TFieldName>(path: TFieldName, value: TFieldValues[TFieldName])` require
+ * compile-time knowledge of the exact form schema.
+ *
+ * Our FormBackend interface is library-agnostic and uses dynamic string paths
+ * (e.g., `"author.name"`, `"items.0.title"`) that can't be statically typed.
+ * TypeScript's `keyof T` doesn't work with nested dot-notation paths.
+ *
+ * The `as never` cast is the safest way to bypass this:
+ * - `never` is the bottom type, so casting TO `never` is always allowed
+ * - It makes the intent explicit: "we're deliberately bypassing type checking here"
+ * - It's more honest than using `any`, which could mask real errors
+ *
+ * Type safety is maintained at the widget layer, where components know their
+ * specific field types and cast immediately after reading values.
+ */
+import type { FieldValues, UseFormReturn } from 'react-hook-form';
+import type { FormBackend } from './types';
+/**
+ * Create RHF backend from react-hook-form instance
+ *
+ * Note: RHF handles validation through its resolver (passed to useForm).
+ * The schema is integrated at form creation time, so we don't need it here.
+ */
+export declare function createRHFBackend<TFieldValues extends FieldValues>(form: UseFormReturn<TFieldValues>): FormBackend;
+export declare function createRHFBackend(form: UseFormReturn<FieldValues>): FormBackend;

package/dist/_dts/block-form/src/backend/store-backend.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Zustand Store backend implementation
+ *
+ * Integrates with EditorUiStore for autosave-enabled form management.
+ * Supports three scopes: blocks (per-block data), metadata (page/entry metadata), and content (content entry data).
+ */
+import type { EditorBlockId, EditorSyncState } from '@riverbankcms/core';
+import type { FormBackend, StoreBackendOptions } from './types';
+type StoreSnapshot = {
+    current: Record<string, unknown> | null;
+    baseline: Record<string, unknown> | null;
+    syncState: EditorSyncState;
+    version?: number;
+};
+interface BlocksSlice {
+    getAtPath: (blockId: EditorBlockId, path: string) => unknown;
+    setAtPath: (blockId: EditorBlockId, path: string, value: unknown) => void;
+    getCurrentValues: (blockId: EditorBlockId) => Record<string, unknown> | null;
+    getBlockSnapshot?: (blockId: EditorBlockId) => StoreSnapshot | null;
+    clearError?: (blockId: EditorBlockId) => void;
+    updateBlockBaseline?: (blockId: EditorBlockId, data: Record<string, unknown> | null) => void;
+}
+interface RootSlice {
+    getAtPath: (path: string) => unknown;
+    setAtPath: (path: string, value: unknown) => void;
+    getCurrentValues: () => Record<string, unknown> | null;
+    getSnapshot?: () => StoreSnapshot | null;
+    clearError?: () => void;
+    hydrate?: (baseline: Record<string, unknown> | null, current: Record<string, unknown> | null) => void;
+}
+interface ArrayKeysManager {
+    get: (scope: string, path: string) => string[] | undefined;
+    set: (scope: string, path: string, keys: string[]) => void;
+    append: (scope: string, path: string, key: string) => void;
+    remove: (scope: string, path: string, index: number) => void;
+    move: (scope: string, path: string, from: number, to: number) => void;
+    insert: (scope: string, path: string, index: number, key: string) => void;
+}
+interface EditorStoreState {
+    drafts?: BlocksSlice;
+    metadata?: RootSlice;
+    content?: RootSlice;
+    blockValidation?: {
+        markPathEdited: (blockId: EditorBlockId, path: string) => void;
+        isPathEdited: (blockId: EditorBlockId, path: string) => boolean;
+        showAllValidation: (blockId: EditorBlockId) => boolean;
+    };
+    arrayKeys: ArrayKeysManager;
+    requestFocus?: (payload: {
+        blockId: EditorBlockId;
+        fieldPath?: string | null;
+    }) => void;
+}
+/**
+ * Create Store backend from Zustand store
+ *
+ * Integrates with editorUiStore for autosave and validation
+ */
+export declare function createStoreBackend(options: StoreBackendOptions<EditorStoreState>): FormBackend;
+export {};

package/dist/_dts/block-form/src/backend/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * FormBackend - Unified backend interface for form operations
+ *
+ * This module provides types for a unified interface that works with either:
+ * - React Hook Form (RHF) for settings forms
+ * - Zustand Store for content editing with autosave
+ *
+ * Validation Flow:
+ * - RHF backends: Validation handled by resolver passed to useForm (zodResolver, etc.)
+ * - Store backends: Validation handled by validateFn option
+ *   Example: createStoreBackend({ validateFn: (values) => schema.safeParse(values).error?.issues ?? [] })
+ */
+import type { ZodIssue } from 'zod';
+import type { FieldValues, UseFormReturn } from 'react-hook-form';
+import type { EditorBlockId } from '@riverbankcms/core';
+/**
+ * Zustand-like store interface for store backend.
+ * We use a minimal contract here to avoid circular dependencies with content-editor.
+ * The actual EditorUiStoreInstance has more methods, but we only require
+ * the core zustand contract at the type level.
+ */
+export interface ZustandLikeStore<TState = unknown> {
+    getState: () => TState;
+    subscribe: (callback: () => void) => () => void;
+}
+export type SetValueOptions = {
+    shouldDirty?: boolean;
+    shouldTouch?: boolean;
+    shouldValidate?: boolean;
+};
+export type FieldError = {
+    message: string;
+    type?: string;
+};
+export type FieldState = {
+    error?: FieldError;
+    isDirty?: boolean;
+    isTouched?: boolean;
+    invalid?: boolean;
+};
+export type FormState = {
+    isDirty: boolean;
+    isValid: boolean;
+    isSubmitting?: boolean;
+    errors: Record<string, FieldError>;
+};
+/**
+ * Unified form backend interface.
+ * Factory functions (createRHFBackend, createStoreBackend) return this interface.
+ *
+ * Internal properties (form, store, scope, blockId) are available for hooks that need
+ * direct access to underlying implementations (e.g., for reactivity).
+ */
+export interface FormBackend {
+    /** Backend type identifier */
+    type: 'rhf' | 'store';
+    /** RHF form instance (RHF backend only) */
+    form?: UseFormReturn<FieldValues>;
+    /** Zustand store instance (Store backend only) */
+    store?: ZustandLikeStore;
+    /** Store scope (Store backend only) */
+    scope?: 'blocks' | 'metadata' | 'content';
+    /** Block ID for blocks scope (Store backend only) */
+    blockId?: EditorBlockId;
+    /** Get value at field path */
+    getValue: (path: string) => unknown;
+    /** Set value at field path with options */
+    setValue: (path: string, value: unknown, options?: SetValueOptions) => void;
+    /** Get all form values */
+    getValues: () => Record<string, unknown>;
+    /** Get field-level state (error, dirty, touched) */
+    getFieldState: (path: string) => FieldState;
+    /** Set custom error on field (for async/server validation) */
+    setError: (path: string, error: FieldError) => void;
+    /** Clear errors (specific field or all) */
+    clearErrors: (path?: string) => void;
+    /** Get all form errors */
+    getErrors: () => Record<string, FieldError>;
+    /** Manually mark field as dirty */
+    setDirty: (path: string, isDirty: boolean) => void;
+    /** Manually mark field as touched */
+    setTouched: (path: string, isTouched: boolean) => void;
+    /** Reset field to default value */
+    resetField: (path: string) => void;
+    /** Request focus on field */
+    setFocus: (path: string) => void;
+    /** Array field operations for repeater widgets */
+    arrayField: {
+        /** Append item to array */
+        append: (path: string, value: unknown) => void;
+        /** Remove item at index */
+        remove: (path: string, index: number) => void;
+        /** Move item from one index to another */
+        move: (path: string, from: number, to: number) => void;
+        /** Insert item at index */
+        insert: (path: string, index: number, value: unknown) => void;
+    };
+    /** Get form-level state */
+    formState: FormState;
+    /** Reset entire form (optionally with new values) */
+    reset: (values?: unknown) => void;
+    /** Trigger validation */
+    validate: () => Promise<boolean>;
+    /**
+     * Subscribe to form changes. Callback fires whenever any value changes.
+     * Returns unsubscribe function.
+     *
+     * This is the unified subscription API - consumers should never branch on backend.type.
+     */
+    subscribe: (callback: () => void) => () => void;
+}
+/**
+ * Options for creating a store backend
+ */
+export type StoreBackendOptions<TState = unknown> = {
+    scope: 'blocks' | 'metadata' | 'content';
+    store: ZustandLikeStore<TState>;
+    blockId?: EditorBlockId;
+    validateFn?: (values: Record<string, unknown>) => ZodIssue[];
+};
+/**
+ * Type guards for discriminating backend types
+ */
+export declare function isRhfBackend(backend: FormBackend): backend is FormBackend & {
+    type: 'rhf';
+    form: UseFormReturn<FieldValues>;
+};
+export declare function isStoreBackend(backend: FormBackend): backend is FormBackend & {
+    type: 'store';
+    store: ZustandLikeStore;
+    scope: 'blocks' | 'metadata' | 'content';
+    blockId?: EditorBlockId;
+};
+export type { FieldDefinition } from '@riverbankcms/blocks';
+export { createRHFBackend } from './rhf-backend';
+export { createStoreBackend } from './store-backend';
+export { useBackendWatch } from './useBackendWatch';

package/dist/_dts/block-form/src/backend/useBackendWatch.d.ts

@@ -0,0 +1,22 @@
+/**
+ * useBackendWatch - Hook for watching field values reactively
+ *
+ * Works with all backends through the unified interface.
+ * For RHF backends, uses react-hook-form's optimized useWatch hook.
+ * For other backends, uses useSyncExternalStore with backend.subscribe/getValue.
+ */
+import type { FormBackend } from './adapter';
+/**
+ * Watch a field path and return its current value.
+ * The value updates reactively when the field changes.
+ *
+ * Uses backend's unified interface - no branching on backend.type.
+ * Detects RHF backend by presence of backend.form property.
+ *
+ * @example
+ * ```tsx
+ * const titleValue = useBackendWatch(backend, 'title')
+ * const statusValue = useBackendWatch(backend, 'status')
+ * ```
+ */
+export declare function useBackendWatch(backend: FormBackend, path: string): unknown;

package/dist/_dts/block-form/src/backend/utils/getErrorMessage.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessage(error: unknown): string | undefined;

package/dist/_dts/block-form/src/blockDraftSaveability.d.ts

@@ -0,0 +1,70 @@
+import { type BlockManifest } from '@riverbankcms/blocks';
+import type { EditorSyncState } from '@riverbankcms/core';
+import type { z } from 'zod';
+type ManifestValidationIssue = z.core.$ZodIssue;
+export type BlockDraftValidationIssue = Readonly<{
+    code: ManifestValidationIssue['code'];
+    path: (string | number)[];
+    fieldPath: string;
+    message: string;
+}>;
+export type BlockManifestValidationMode = 'draft' | 'strict';
+export type BlockDraftSaveability = Readonly<{
+    kind: 'pristine';
+    issues: readonly BlockDraftValidationIssue[];
+}> | Readonly<{
+    kind: 'incomplete';
+    issues: readonly BlockDraftValidationIssue[];
+}> | Readonly<{
+    kind: 'saveable';
+    issues: readonly [];
+}> | Readonly<{
+    kind: 'save_failed';
+    issues: readonly BlockDraftValidationIssue[];
+    error: string;
+}>;
+export declare const unfinishedBlockCopy: {
+    readonly title: "Fix this block to save it";
+    readonly description: "Some fields need a quick check. Your changes are safe here for now.";
+};
+export declare const recoveryConflictCopy: {
+    readonly reviewActionLabel: "Review affected blocks";
+    readonly discardActionLabel: "Discard browser recovery";
+    readonly blockNoticeTitle: "We couldn’t restore unfinished edits here automatically";
+    readonly blockNoticeDescription: "The saved version changed before we could put them back.";
+    readonly pageNoticeDescription: "The saved page changed, so we couldn’t restore them automatically.";
+};
+export declare const unfinishedBlocksSummaryCopy: {
+    readonly singular: "1 block still needs attention";
+    readonly plural: (count: number) => string;
+};
+export declare const publishBlockedCopy: {
+    readonly singleInvalidBlock: (blockLabel: string) => string;
+    readonly multipleInvalidBlocks: (count: number) => string;
+};
+export declare function formatRecoveryConflictTitle(count: number): string;
+export declare function formatRecoveryConflictSummary(count: number): string | null;
+export declare function formatUnfinishedBlocksSummary(count: number): string | null;
+export declare function formatPublishBlockedMessage(input: Readonly<{
+    type: 'single-invalid-block';
+    blockLabel: string;
+} | {
+    type: 'multiple-invalid-blocks';
+    count: number;
+}>): string;
+export declare function deriveBlockDraftSaveability(input: {
+    syncState: EditorSyncState;
+    issues: readonly BlockDraftValidationIssue[];
+    hasMeaningfulEdit: boolean;
+    showAllValidation: boolean;
+}): BlockDraftSaveability;
+export declare function shouldShowBlockFieldValidation(input: {
+    fieldPath: string;
+    touchedPaths: ReadonlySet<string>;
+    showAllValidation: boolean;
+}): boolean;
+export declare function validateBlockManifestValues(manifest: BlockManifest, values: Record<string, unknown>): BlockDraftValidationIssue[];
+export declare function validateBlockManifestIssues(manifest: BlockManifest, values: Record<string, unknown>, mode: BlockManifestValidationMode): ManifestValidationIssue[];
+export declare function validateBlockManifest(manifest: BlockManifest, values: Record<string, unknown>, mode: BlockManifestValidationMode): BlockDraftValidationIssue[];
+export declare function normalizeManifestIssueMessage(issue: ManifestValidationIssue): string;
+export {};

package/dist/_dts/block-form/src/client/blockDraftSaveability.d.ts

@@ -0,0 +1 @@
+export * from '../blockDraftSaveability';

package/dist/_dts/block-form/src/client/index.d.ts

@@ -0,0 +1,30 @@
+export { FormRenderer } from '../FormRenderer';
+export type { FormRendererProps } from '../FormRenderer';
+export { ManifestForm } from '../manifest/ManifestForm';
+export type { ManifestFormProps } from '../manifest/ManifestForm';
+export type { FieldWidgetComponent, FieldWidgetProps } from '../fields/props';
+export { useField, useArrayField } from '../backend/hooks';
+export { createRHFBackend, createStoreBackend, useBackendWatch } from '../backend/types';
+export type { FormBackend, FieldError, FieldState, SetValueOptions } from '../backend/types';
+export type { ManifestAdapterOptions, ManifestAdapterResult, ManifestFormSource, ManifestSchemaOptions, ManifestValidationResult, } from '../manifest/manifestFormAdapter';
+export { createManifestValidation } from '../manifest/manifestFormAdapter';
+export { formatPublishBlockedMessage, formatRecoveryConflictSummary, formatRecoveryConflictTitle, deriveBlockDraftSaveability, formatUnfinishedBlocksSummary, normalizeManifestIssueMessage, recoveryConflictCopy, shouldShowBlockFieldValidation, unfinishedBlockCopy, validateBlockManifest, validateBlockManifestIssues, validateBlockManifestValues, } from './blockDraftSaveability';
+export type { BlockDraftSaveability, BlockDraftValidationIssue, BlockManifestValidationMode, } from './blockDraftSaveability';
+export type { BaseFieldConfig, FieldConfig, TextFieldConfig, NumberFieldConfig, RichTextFieldConfig, MediaFieldConfig, BooleanFieldConfig, DateFieldConfig, TimeFieldConfig, DateTimeFieldConfig, SlugFieldConfig, UrlFieldConfig, LinkFieldConfig, SelectFieldConfig, ReferenceFieldConfig, GroupFieldConfig, RepeaterFieldConfig, ButtonFieldConfig, ContentTypeSelectFieldConfig, EntryPickerFieldConfig, } from '../fields/types';
+export { createManifestFormAdapter } from '../manifest/manifestFormAdapter';
+export { PaletteProvider, usePalette } from '../palette/PaletteContext';
+export { SdkConfigProvider, useSdkConfig, useBlockFieldOptions } from '../sdk-config';
+export type { SdkConfig, SdkConfigProviderProps, SdkThemePalette, SdkSectionBackground, SdkSectionOptions, SdkSiteStyleConfig, SdkFieldSelectOption, SdkBlockFieldConfig, SdkBlockFieldOptionsMap, SdkBlockFieldExtensionsMap, } from '../sdk-config';
+export { BlockContextProvider, useBlockContext } from '../context';
+export type { BlockContextValue, BlockContextProviderProps } from '../context';
+export { DisplayLabelResolverProvider, useDisplayLabelResolvers } from '../context';
+export type { DisplayLabelResolver, DisplayLabelResolverMap, ResolverCallContext } from '../context';
+export { FieldPreviewResolverProvider, useFieldPreviewResolvers } from '../context';
+export type { FieldPreviewResolver, FieldPreviewResolverMap, FieldPreviewResolverCallContext } from '../context';
+export { ImageResolveContextProvider, useImageResolveContextOptional } from '../context';
+export { mergeManifestWithSdkOptions } from '../manifest/mergeManifestWithSdkOptions';
+export { FieldFrame, FieldFrameMessage } from '../widgets/FieldFrame';
+export type { FieldFrameProps, FieldFrameRenderProps, FieldFrameMessageProps } from '../widgets/FieldFrame';
+export { SelectField } from '../widgets/SelectField';
+export { BackgroundColorField } from '../widgets/BackgroundColorWidget';
+export { BackgroundGradientField } from '../widgets/BackgroundGradientWidget';

package/dist/_dts/block-form/src/context/BlockContext.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+/**
+ * Block context value
+ *
+ * Provides information about the current block being edited.
+ * Used by widgets like SdkSelectField to look up SDK-provided field options.
+ */
+export interface BlockContextValue {
+    /** The block kind (e.g., 'block.embed', 'custom.hero') */
+    blockKind: string;
+}
+export interface BlockContextProviderProps {
+    blockKind: string;
+    children: React.ReactNode;
+}
+/**
+ * BlockContextProvider
+ *
+ * Provides block information to child widgets.
+ * Typically used by FormRenderer when editing a block.
+ */
+export declare function BlockContextProvider({ blockKind, children }: BlockContextProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * useBlockContext
+ *
+ * Hook to access the current block context.
+ * Returns null when not within a BlockContextProvider.
+ */
+export declare function useBlockContext(): BlockContextValue | null;

package/dist/_dts/block-form/src/context/DisplayLabelResolverContext.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { FieldConfig } from '../fields/types';
+/**
+ * Context passed to a display label resolver, providing access to sibling field values.
+ */
+export type ResolverCallContext = {
+    getSiblingValue: (fieldId: string) => unknown;
+};
+/**
+ * A function that resolves a stored field value to a human-readable display label.
+ *
+ * Returns null if the value can't be resolved (caller falls back to raw value).
+ */
+export type DisplayLabelResolver = (value: unknown, fieldConfig: FieldConfig, context: ResolverCallContext) => Promise<string | null>;
+/**
+ * Map of field type to display label resolver.
+ * Only field types that need async resolution register here.
+ */
+export type DisplayLabelResolverMap = Partial<Record<FieldConfig['type'], DisplayLabelResolver>>;
+/**
+ * Provides display label resolvers to descendant components.
+ * Repeater items use these resolvers to show human-readable labels
+ * instead of raw stored values (e.g. entry titles instead of slugs).
+ */
+export declare function DisplayLabelResolverProvider({ resolvers, children, }: {
+    resolvers: DisplayLabelResolverMap;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * Access the display label resolver map.
+ * Returns an empty map when no provider is present (resolvers are optional).
+ */
+export declare function useDisplayLabelResolvers(): DisplayLabelResolverMap;