@riverbankcms/sdk 0.62.4 → 0.64.0

package/dist/_dts/api/src/sdkConfig/contracts.d.ts

@@ -246,6 +246,8 @@ export declare const SDK_WORKFLOW_DESCRIPTION_MAX_LENGTH = 500;
 export declare const SDK_WORKFLOW_CONTENT_TYPE_MAX_LENGTH = 120;
 export declare const SDK_WORKFLOW_ENDPOINT_MAX_LENGTH = 500;
 export declare const SDK_WORKFLOW_TRIGGER_MAX_COUNT = 5;
+export declare const SDK_WORKFLOW_TRIGGER_FIELD_MAX_LENGTH = 120;
+export declare const SDK_WORKFLOW_TRIGGER_CONDITION_MAX_COUNT = 10;
 export declare const SDK_WORKFLOW_MAX_COUNT = 50;
 export declare const SDK_WORKFLOW_CONFIRMATION_TITLE_MAX_LENGTH = 120;
 export declare const SDK_WORKFLOW_CONFIRMATION_BODY_MAX_LENGTH = 500;
@@ -253,6 +255,15 @@ export declare const SDK_WORKFLOW_ID_PATTERN: RegExp;
 export declare const SDK_WORKFLOW_ENDPOINT_PATTERN: RegExp;
 export declare const sdkWorkflowTriggerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"manual">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"entry.draft.updated">;
+    when: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        field: z.ZodString;
+        changed: z.ZodLiteral<true>;
+    }, z.core.$strict>, z.ZodObject<{
+        field: z.ZodString;
+        isEmpty: z.ZodBoolean;
+    }, z.core.$strict>]>>;
 }, z.core.$strict>], "type">;
 export declare const sdkWorkflowConfirmationSchema: z.ZodObject<{
     title: z.ZodString;
@@ -266,6 +277,15 @@ export declare const sdkWorkflowConfigSchema: z.ZodObject<{
     endpoint: z.ZodString;
     triggers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"manual">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"entry.draft.updated">;
+        when: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            changed: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            field: z.ZodString;
+            isEmpty: z.ZodBoolean;
+        }, z.core.$strict>]>>;
     }, z.core.$strict>], "type">>;
     confirmation: z.ZodOptional<z.ZodObject<{
         title: z.ZodString;
@@ -280,6 +300,15 @@ export declare const sdkWorkflowsSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
     endpoint: z.ZodString;
     triggers: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"manual">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"entry.draft.updated">;
+        when: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            field: z.ZodString;
+            changed: z.ZodLiteral<true>;
+        }, z.core.$strict>, z.ZodObject<{
+            field: z.ZodString;
+            isEmpty: z.ZodBoolean;
+        }, z.core.$strict>]>>;
     }, z.core.$strict>], "type">>;
     confirmation: z.ZodOptional<z.ZodObject<{
         title: z.ZodString;

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

@@ -84,9 +84,21 @@ export interface SdkContentConfig {
     navigationMenus?: unknown[];
     settings?: unknown;
 }
-export type SdkWorkflowTrigger = {
+export type SdkWorkflowManualTrigger = {
     type: "manual";
 };
+export type SdkWorkflowEntryDraftUpdatedCondition = Readonly<{
+    field: string;
+    changed: true;
+}> | Readonly<{
+    field: string;
+    isEmpty: boolean;
+}>;
+export type SdkWorkflowEntryDraftUpdatedTrigger = {
+    type: "entry.draft.updated";
+    when: SdkWorkflowEntryDraftUpdatedCondition[];
+};
+export type SdkWorkflowTrigger = SdkWorkflowManualTrigger | SdkWorkflowEntryDraftUpdatedTrigger;
 export type SdkWorkflowConfirmation = {
     title: string;
     body?: string;

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

@@ -242,6 +242,10 @@ export type AcknowledgeLaunchRequirementResponse = {
     acknowledged: true;
     requirementId: Extract<LaunchRequirementId, "review_generated_site" | "configure_appointments">;
 };
+export declare const goLiveSiteRequestSchema: z.ZodObject<{
+    acceptExtraSiteCharge: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GoLiveSiteRequest = z.infer<typeof goLiveSiteRequestSchema>;
 export type GoLiveSiteResponse = {
     redirectPath: string;
 };

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

@@ -110,6 +110,16 @@ export type AdminSiteCostUpdateSyncResult = {
 export type AdminUpdateSiteCostResponse = AdminSiteCostResponse & {
     subscriptionSync: AdminSiteCostUpdateSyncResult;
 };
+export type AdminScheduleBillingComponentEndRequest = {
+    reason?: string;
+};
+export type AdminScheduleBillingComponentEndResponse = {
+    component: {
+        id: string;
+        status: "ending" | "ended";
+        endsAt: string;
+    };
+};
 export type ListGscPropertiesAdminResponse = {
     properties: Array<{
         id: string;

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

@@ -26,6 +26,31 @@ export type SiteThemeSelectionsPayload = {
     headerLookId?: HeaderLookId | null;
     footerLookId?: FooterLookId | null;
 };
+export type SaveSiteChromeLookSelectionBody = Readonly<{
+    surface: 'header';
+    lookId: HeaderLookId | null;
+    theme: Theme;
+    themeId?: string | null;
+    selectionId?: string | null;
+    baseSelectionUpdatedAt?: string | null;
+}> | Readonly<{
+    surface: 'footer';
+    lookId: FooterLookId | null;
+    theme: Theme;
+    themeId?: string | null;
+    selectionId?: string | null;
+    baseSelectionUpdatedAt?: string | null;
+}>;
+export type SaveSiteChromeLookSelectionResponse = Readonly<{
+    success: boolean;
+    themeId: string;
+    selectionId: string;
+    selectionUpdatedAt: string | null;
+    savedAt: string;
+    theme: Theme;
+    headerLookId: HeaderLookId | null;
+    footerLookId: FooterLookId | null;
+}>;
 export type PageDesignRevisionToken = {
     kind: 'absent';
 } | {
@@ -154,6 +179,7 @@ export type SiteRuntimeAPIEndpoints = {
         success: boolean;
         themeId: string;
         selectionId: string;
+        selectionUpdatedAt: string | null;
         savedAt: string;
         overrides: Record<string, unknown> | null;
         theme: Theme;
@@ -171,6 +197,9 @@ export type SiteRuntimeAPIEndpoints = {
         headerLookId: HeaderLookId | null;
         footerLookId: FooterLookId | null;
     }>;
+    saveSiteChromeLookSelection: APIEndpoint<SaveSiteChromeLookSelectionBody, {
+        siteId: string;
+    }, SaveSiteChromeLookSelectionResponse>;
     uploadSiteLogo: APIEndpoint<UploadSiteLogoRequest, never, {
         path: string;
         publicUrl: string | null;

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

@@ -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;