@stonecrop/stonecrop 0.4.37 → 0.6.0

package/dist/stonecrop.d.ts

@@ -2,18 +2,61 @@ import type { AnyStateNodeConfig } from 'xstate';
 import { Component } from 'vue';
 import { ComputedRef } from 'vue';
 import { CSSProperties } from 'vue';
+import { HSTOperation as HSTOperation_2 } from './types';
+import { HSTOperation as HSTOperation_3 } from '..';
+import { HSTOperationInput as HSTOperationInput_2 } from './types';
+import { HSTOperationType as HSTOperationType_2 } from './types';
+import { HSTOperationType as HSTOperationType_3 } from '..';
 import { List } from 'immutable';
 import { Map as Map_2 } from 'immutable';
+import { OperationLogSnapshot as OperationLogSnapshot_2 } from './types';
+import { OperationLogSnapshot as OperationLogSnapshot_3 } from '..';
+import { OperationSource as OperationSource_2 } from './types';
+import { OperationSource as OperationSource_3 } from '..';
 import { Plugin as Plugin_2 } from 'vue';
 import { Ref } from 'vue';
 import { Router } from 'vue-router';
 import type { ShallowRef } from 'vue';
 import { Store } from 'pinia';
 import { StoreDefinition } from 'pinia';
+import { UndoRedoState as UndoRedoState_2 } from './types';
+import { UndoRedoState as UndoRedoState_3 } from '..';
 import type { UnknownMachineConfig } from 'xstate';
 import { useElementBounding } from '@vueuse/core';
 import { WritableComputedRef } from 'vue';
 
+/**
+ * Result of executing a field action
+ * @public
+ */
+export declare interface ActionExecutionResult {
+    /** Whether the action executed successfully */
+    success: boolean;
+    /** Error if execution failed */
+    error?: Error;
+    /** Execution time in milliseconds */
+    executionTime: number;
+    /** The action that was executed */
+    action: FieldAction;
+}
+
+/**
+ * Registry for storing global action functions
+ * @public
+ */
+export declare interface ActionRegistry {
+    /** Register a global action function */
+    register(name: string, fn: FieldActionFunction): void;
+    /** Get a registered action function */
+    get(name: string): FieldActionFunction | undefined;
+    /** Check if an action is registered */
+    has(name: string): boolean;
+    /** Unregister an action function */
+    unregister(name: string): void;
+    /** Get all registered action names */
+    list(): string[];
+}
+
 /**
  * Basic field structure for AForm schemas
  * @public
@@ -41,6 +84,15 @@ export declare type BaseSchema = {
     value?: any;
 };
 
+/**
+ * Base Stonecrop composable return type - includes operation log functionality
+ * @public
+ */
+export declare type BaseStonecropReturn = {
+    stonecrop: Ref<Stonecrop | undefined>;
+    operationLog: OperationLogAPI;
+};
+
 /**
  * Base table configuration properties shared across all view types.
  * @public
@@ -65,6 +117,23 @@ export declare interface BasicTableConfig extends BaseTableConfig {
     view?: 'uncounted' | 'list' | 'list-expansion';
 }
 
+/**
+ * Batch operation wrapper
+ * @public
+ */
+export declare interface BatchOperation {
+    /** Unique batch identifier */
+    id: string;
+    /** Operations included in this batch */
+    operations: HSTOperation[];
+    /** When the batch was created */
+    timestamp: Date;
+    /** Optional description of what this batch represents */
+    description?: string;
+    /** Whether the entire batch can be undone */
+    reversible: boolean;
+}
+
 /**
  * Table cell context definition.
  * @public
@@ -218,6 +287,19 @@ export declare interface ConnectionPath {
     label?: string;
 }
 
+/**
+ * Factory function for HST creation
+ * Creates a new HSTNode proxy for hierarchical state tree navigation.
+ *
+ * @param target - The target object to wrap with HST functionality
+ * @param doctype - The document type identifier
+ * @param parentDoctype - Optional parent document type identifier
+ * @returns A new HSTNode proxy instance
+ *
+ * @public
+ */
+export declare function createHST(target: any, doctype: string, parentDoctype?: string): HSTNode;
+
 /**
  * Create a table store
  * @param initData - Initial data for the table store
@@ -1009,6 +1091,29 @@ updateGanttBar: (event: GanttDragEvent) => void;
 updateRows: (newRows: TableRow[]) => void;
 }, "closeModal" | "createConnection" | "deleteConnection" | "getCellData" | "getCellDisplayValue" | "getConnectionsForBar" | "getFormattedValue" | "getHandlesForBar" | "getHeaderCellStyle" | "getIndent" | "getRowExpandSymbol" | "isRowGantt" | "isRowVisible" | "registerConnectionHandle" | "registerGanttBar" | "resizeColumn" | "setCellData" | "setCellText" | "toggleRowExpand" | "unregisterConnectionHandle" | "unregisterGanttBar" | "updateGanttBar" | "updateRows">>;
 
+/**
+ * Cross-tab message payload
+ * @public
+ */
+export declare interface CrossTabMessage {
+    /** Type of cross-tab message */
+    type: CrossTabMessageType;
+    /** Single operation for operation/undo/redo messages */
+    operation?: HSTOperation;
+    /** Multiple operations for sync messages */
+    operations?: HSTOperation[];
+    /** Identifier of the client/tab sending the message */
+    clientId: string;
+    /** When the message was sent */
+    timestamp: Date;
+}
+
+/**
+ * Cross-tab message types
+ * @public
+ */
+export declare type CrossTabMessageType = 'operation' | 'undo' | 'redo' | 'sync-request' | 'sync-response';
+
 /**
  * Doctype Meta class
  * @public
@@ -1033,7 +1138,7 @@ export declare class DoctypeMeta {
      */
     readonly workflow: ImmutableDoctype['workflow'];
     /**
-     * The doctype actions
+     * The doctype actions and field triggers
      * @public
      * @readonly
      */
@@ -1044,6 +1149,14 @@ export declare class DoctypeMeta {
      * @readonly
      */
     readonly component?: Component;
+    /**
+     * Creates a new DoctypeMeta instance
+     * @param doctype - The doctype name
+     * @param schema - The doctype schema definition
+     * @param workflow - The doctype workflow configuration (XState machine)
+     * @param actions - The doctype actions and field triggers
+     * @param component - Optional Vue component for rendering the doctype
+     */
     constructor(doctype: string, schema: ImmutableDoctype['schema'], workflow: ImmutableDoctype['workflow'], actions: ImmutableDoctype['actions'], component?: Component);
     /**
      * Converts the registered doctype string to a slug (kebab-case). The following conversions are made:
@@ -1064,6 +1177,49 @@ export declare class DoctypeMeta {
     get slug(): string;
 }
 
+/**
+ * Supported action types for field triggers
+ * @public
+ */
+export declare type FieldAction = FieldActionFunction | FieldActionString;
+
+/**
+ * Action function that can be triggered by field changes
+ * @public
+ */
+export declare type FieldActionFunction = (context: FieldChangeContext) => void | Promise<void>;
+
+/**
+ * String reference to a globally registered action function or inline function
+ * @public
+ */
+export declare type FieldActionString = string;
+
+/**
+ * Context provided to action functions when field changes occur
+ * @public
+ */
+export declare interface FieldChangeContext {
+    /** The HST path that was changed */
+    path: string;
+    /** The field name (last segment of path) */
+    fieldname: string;
+    /** Value before the change */
+    beforeValue: any;
+    /** Value after the change */
+    afterValue: any;
+    /** The operation type */
+    operation: 'set' | 'delete' | 'patch';
+    /** The doctype of the record being changed */
+    doctype: string;
+    /** The record ID if applicable */
+    recordId?: string;
+    /** Timestamp of the change */
+    timestamp: Date;
+    /** Reference to the HST store for state access (optional) */
+    store?: HSTNode;
+}
+
 /**
  * Schema structure for defining fieldsets inside AForm
  * @public
@@ -1086,6 +1242,193 @@ export declare type FieldsetSchema = BaseSchema & {
     collapsible?: boolean;
 };
 
+/**
+ * Configuration for a single field trigger
+ * @public
+ */
+export declare interface FieldTriggerConfig {
+    /** Array of actions to execute when this field changes */
+    actions: FieldAction[];
+    /** Optional condition function to determine if actions should run */
+    condition?: (context: FieldChangeContext) => boolean | Promise<boolean>;
+    /** Whether to run actions before or after the value is set (default: 'after') */
+    timing?: 'before' | 'after';
+    /** Whether to stop execution on first error (default: true) */
+    stopOnError?: boolean;
+    /** Maximum execution time in milliseconds before timeout */
+    timeout?: number;
+    /** Whether to enable automatic rollback for this field trigger (overrides global setting) */
+    enableRollback?: boolean;
+}
+
+/**
+ * Field trigger execution engine integrated with Registry
+ * Singleton pattern following Registry implementation
+ * @public
+ */
+export declare class FieldTriggerEngine {
+    /**
+     * The root FieldTriggerEngine instance
+     */
+    static _root: FieldTriggerEngine;
+    private options;
+    private doctypeActions;
+    private doctypeTransitions;
+    private fieldRollbackConfig;
+    private globalActions;
+    private globalTransitionActions;
+    /**
+     * Creates a new FieldTriggerEngine instance (singleton pattern)
+     * @param options - Configuration options for the field trigger engine
+     */
+    constructor(options?: FieldTriggerOptions);
+    /**
+     * Register a global action function
+     * @param name - The name of the action
+     * @param fn - The action function
+     */
+    registerAction(name: string, fn: FieldActionFunction): void;
+    /**
+     * Register a global XState transition action function
+     * @param name - The name of the transition action
+     * @param fn - The transition action function
+     */
+    registerTransitionAction(name: string, fn: TransitionActionFunction): void;
+    /**
+     * Configure rollback behavior for a specific field trigger
+     * @param doctype - The doctype name
+     * @param fieldname - The field name
+     * @param enableRollback - Whether to enable rollback
+     */
+    setFieldRollback(doctype: string, fieldname: string, enableRollback: boolean): void;
+    /**
+     * Get rollback configuration for a specific field trigger
+     */
+    private getFieldRollback;
+    /**
+     * Register actions from a doctype - both regular actions and field triggers
+     * Separates XState transitions (uppercase) from field triggers (lowercase)
+     * @param doctype - The doctype name
+     * @param actions - The actions to register (supports Immutable Map, Map, or plain object)
+     */
+    registerDoctypeActions(doctype: string, actions: Map_2<string, string[]> | Map<string, string[]> | Record<string, string[]> | undefined): void;
+    /**
+     * Categorize an action as either a field trigger or XState transition
+     * Uses uppercase convention: UPPERCASE = transition, lowercase/mixed = field trigger
+     */
+    private categorizeAction;
+    /**
+     * Determine if a key represents an XState transition
+     * Transitions are identified by being all uppercase
+     */
+    private isTransitionKey;
+    /**
+     * Execute field triggers for a changed field
+     * @param context - The field change context
+     * @param options - Execution options (timeout and enableRollback)
+     */
+    executeFieldTriggers(context: FieldChangeContext, options?: {
+        timeout?: number;
+        enableRollback?: boolean;
+    }): Promise<FieldTriggerExecutionResult>;
+    /**
+     * Execute XState transition actions
+     * Similar to field triggers but specifically for FSM state transitions
+     * @param context - The transition change context
+     * @param options - Execution options (timeout)
+     */
+    executeTransitionActions(context: TransitionChangeContext, options?: {
+        timeout?: number;
+    }): Promise<TransitionExecutionResult[]>;
+    /**
+     * Find transition actions for a specific doctype and transition
+     */
+    private findTransitionActions;
+    /**
+     * Execute a single transition action by name
+     */
+    private executeTransitionAction;
+    /**
+     * Find field triggers for a specific doctype and field
+     * Field triggers are identified by keys that look like field paths (contain dots or match field names)
+     */
+    private findFieldTriggers;
+    /**
+     * Determine if an action key represents a field trigger
+     * Field triggers can be:
+     * - Exact field name match: "emailAddress"
+     * - Wildcard patterns: "emailAddress.*", "*.is_primary"
+     * - Nested field paths: "address.street", "contact.email"
+     */
+    private isFieldTriggerKey;
+    /**
+     * Match a field pattern against a field name
+     * Supports wildcards (*) for dynamic segments
+     */
+    private matchFieldPattern;
+    /**
+     * Execute a single action by name
+     */
+    private executeAction;
+    /**
+     * Execute a function with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Capture a snapshot of the record state before executing actions
+     * This creates a deep copy of the record data for potential rollback
+     */
+    private captureSnapshot;
+    /**
+     * Restore a previously captured snapshot
+     * This reverts the record to its state before actions were executed
+     */
+    private restoreSnapshot;
+}
+
+/**
+ * Result of executing all actions for a field change
+ * @public
+ */
+export declare interface FieldTriggerExecutionResult {
+    /** The path that triggered the actions */
+    path: string;
+    /** Results for each action that was executed */
+    actionResults: ActionExecutionResult[];
+    /** Total execution time for all actions */
+    totalExecutionTime: number;
+    /** Whether all actions succeeded */
+    allSucceeded: boolean;
+    /** Whether execution was stopped due to an error */
+    stoppedOnError: boolean;
+    /** Whether a rollback was performed */
+    rolledBack: boolean;
+    /** The snapshot that was captured before execution */
+    snapshot?: any;
+}
+
+/**
+ * Map of field paths to trigger configurations
+ * Supports wildcard patterns like 'emailAddress.*.is_primary'
+ * @public
+ */
+export declare type FieldTriggerMap = Record<string, FieldTriggerConfig | FieldAction[]>;
+
+/**
+ * Options for the field trigger system
+ * @public
+ */
+export declare interface FieldTriggerOptions {
+    /** Default timeout for action execution in milliseconds */
+    defaultTimeout?: number;
+    /** Whether to log trigger executions for debugging */
+    debug?: boolean;
+    /** Custom error handler for action failures */
+    errorHandler?: (error: Error, context: FieldChangeContext, action: FieldAction) => void;
+    /** Whether to enable automatic rollback on failure (default: true) */
+    enableRollback?: boolean;
+}
+
 /**
  * Schema structure for defining forms inside AForm
  * @public
@@ -1261,6 +1604,200 @@ export declare interface GanttTableConfig extends BaseTableConfig {
     dependencyGraph?: boolean;
 }
 
+/**
+ * Get or create the global field trigger engine singleton
+ * @param options - Optional configuration for the field trigger engine
+ * @public
+ */
+export declare function getGlobalTriggerEngine(options?: FieldTriggerOptions): FieldTriggerEngine;
+
+/**
+ * Global HST Manager (Singleton)
+ * Manages hierarchical state trees and provides access to the global registry.
+ *
+ * @public
+ */
+export declare class HST {
+    private static instance;
+    /**
+     * Gets the singleton instance of HST
+     * @returns The HST singleton instance
+     */
+    static getInstance(): HST;
+    /**
+     * Gets the global registry instance
+     * @returns The global registry object or undefined if not found
+     */
+    getRegistry(): any;
+    /**
+     * Helper method to get doctype metadata from the registry
+     * @param doctype - The name of the doctype to retrieve metadata for
+     * @returns The doctype metadata object or undefined if not found
+     */
+    getDoctypeMeta(doctype: string): any;
+}
+
+/**
+ * HST Change data structure
+ * @public
+ */
+export declare type HSTChangeData = {
+    path: string;
+    value: any;
+    fieldname: string;
+    recordId?: string;
+};
+
+/**
+ * Core HST Interface - enhanced with tree navigation
+ * Provides a hierarchical state tree interface for navigating and manipulating nested data structures.
+ *
+ * @public
+ */
+export declare interface HSTNode {
+    /**
+     * Gets a value at the specified path
+     * @param path - The dot-separated path to the value
+     * @returns The value at the specified path
+     */
+    get(path: string): any;
+    /**
+     * Sets a value at the specified path
+     * @param path - The dot-separated path where to set the value
+     * @param value - The value to set
+     * @param source - Optional source of the operation (user, system, sync, undo, redo)
+     */
+    set(path: string, value: any, source?: 'user' | 'system' | 'sync' | 'undo' | 'redo'): void;
+    /**
+     * Checks if a value exists at the specified path
+     * @param path - The dot-separated path to check
+     * @returns True if the path exists, false otherwise
+     */
+    has(path: string): boolean;
+    /**
+     * Gets the parent node in the tree hierarchy
+     * @returns The parent HSTNode or null if this is the root
+     */
+    getParent(): HSTNode | null;
+    /**
+     * Gets the root node of the tree
+     * @returns The root HSTNode
+     */
+    getRoot(): HSTNode;
+    /**
+     * Gets the full path from root to this node
+     * @returns The dot-separated path string
+     */
+    getPath(): string;
+    /**
+     * Gets the depth level of this node in the tree
+     * @returns The depth as a number (0 for root)
+     */
+    getDepth(): number;
+    /**
+     * Gets an array of path segments from root to this node
+     * @returns Array of path segments representing breadcrumbs
+     */
+    getBreadcrumbs(): string[];
+    /**
+     * Gets a child node at the specified relative path
+     * @param path - The relative path to the child node
+     * @returns The child HSTNode
+     */
+    getNode(path: string): HSTNode;
+    /**
+     * Trigger an XState transition with optional context data
+     * @param transition - The transition name (should be uppercase per convention)
+     * @param context - Optional additional FSM context data
+     * @returns Promise resolving to the transition execution results
+     */
+    triggerTransition(transition: string, context?: {
+        currentState?: string;
+        targetState?: string;
+        fsmContext?: Record<string, any>;
+    }): Promise<any>;
+}
+
+/**
+ * Complete metadata for an HST mutation
+ * Enables time travel, synchronization, and audit trails
+ * @public
+ */
+export declare interface HSTOperation {
+    /** Unique operation identifier */
+    id: string;
+    /** Type of operation performed */
+    type: HSTOperationType;
+    /** Full HST path affected (e.g., "task.123.title") */
+    path: string;
+    /** Field name extracted from path */
+    fieldname: string;
+    /** Value before the operation */
+    beforeValue: any;
+    /** Value after the operation */
+    afterValue: any;
+    /** Doctype this operation affects */
+    doctype: string;
+    /** Record ID if applicable */
+    recordId?: string;
+    /** Timestamp of the operation */
+    timestamp: Date;
+    /** Source of the operation (defaults to 'user' if not specified) */
+    source?: OperationSource;
+    /** Whether this operation can be undone */
+    reversible: boolean;
+    /** Reason if operation is irreversible */
+    irreversibleReason?: string;
+    /** XState transition name if triggered by FSM */
+    transition?: string;
+    /** XState current state before transition */
+    currentState?: string;
+    /** XState target state after transition */
+    targetState?: string;
+    /** Action name if operation is an action execution (type: 'action') */
+    actionName?: string;
+    /** Record IDs that the action was executed on */
+    actionRecordIds?: string[];
+    /** Result or status of the action execution */
+    actionResult?: 'success' | 'failure' | 'pending';
+    /** Error message if action execution failed */
+    actionError?: string;
+    /** User or session identifier */
+    userId?: string;
+    /** Additional metadata for custom use cases */
+    metadata?: Record<string, any>;
+    /** Parent operation ID for batch operations */
+    parentOperationId?: string;
+    /** Child operation IDs for batch operations */
+    childOperationIds?: string[];
+}
+
+/**
+ * Input type for adding operations
+ * Excludes system-generated fields (id, timestamp)
+ * @public
+ */
+export declare type HSTOperationInput = Omit<HSTOperation, 'id' | 'timestamp' | 'source'> & {
+    source?: OperationSource;
+};
+
+/**
+ * Type of HST operation
+ * @public
+ */
+export declare type HSTOperationType = 'set' | 'delete' | 'batch' | 'transition' | 'action';
+
+/**
+ * HST-enabled Stonecrop composable return type
+ * @public
+ */
+export declare type HSTStonecropReturn = BaseStonecropReturn & {
+    provideHSTPath: (fieldname: string, recordId?: string) => string;
+    handleHSTChange: (changeData: HSTChangeData) => void;
+    hstStore: Ref<HSTNode | undefined>;
+    formData: Ref<Record<string, any>>;
+};
+
 /**
  * Immutable Doctype type for Stonecrop instances
  * @public
@@ -1278,19 +1815,168 @@ export declare type ImmutableDoctype = {
 export declare type InstallOptions = {
     router?: Router;
     components?: Record<string, Component>;
-    getMeta?: (doctype?: string) => DoctypeMeta | Promise<DoctypeMeta>;
+    getMeta?: (routeContext: RouteContext) => DoctypeMeta | Promise<DoctypeMeta>;
+    /** Automatically run initialization callback after app mounting (default: false) */
+    autoInitializeRouter?: boolean;
+    /** Callback function called after plugin is ready and mounted */
+    onRouterInitialized?: (registry: Registry, stonecrop: Stonecrop) => void | Promise<void>;
 };
 
+/**
+ * Mark a specific operation as irreversible.
+ * Used to prevent undo of critical operations like publishing or deletion.
+ * @param operationId - The ID of the operation to mark as irreversible
+ * @param reason - Human-readable reason why the operation cannot be undone
+ * @public
+ */
+export declare function markOperationIrreversible(operationId: string | undefined, reason: string): void;
+
 /**
  * Mutable Doctype type for Stonecrop instances
  * @public
  */
 export declare type MutableDoctype = {
+    doctype?: string;
     schema?: SchemaTypes[];
     workflow?: UnknownMachineConfig | AnyStateNodeConfig;
     actions?: Record<string, string[]>;
 };
 
+/**
+ * Operation Log API - nested object containing all operation log functionality
+ * @public
+ */
+export declare type OperationLogAPI = {
+    operations: Ref<HSTOperation[]>;
+    currentIndex: Ref<number>;
+    undoRedoState: ComputedRef<{
+        canUndo: boolean;
+        canRedo: boolean;
+        undoCount: number;
+        redoCount: number;
+        currentIndex: number;
+    }>;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoCount: ComputedRef<number>;
+    redoCount: ComputedRef<number>;
+    undo: (hstStore: HSTNode) => boolean;
+    redo: (hstStore: HSTNode) => boolean;
+    startBatch: () => void;
+    commitBatch: (description?: string) => string | null;
+    cancelBatch: () => void;
+    clear: () => void;
+    getOperationsFor: (doctype: string, recordId?: string) => HSTOperation[];
+    getSnapshot: () => OperationLogSnapshot;
+    markIrreversible: (operationId: string, reason: string) => void;
+    logAction: (doctype: string, actionName: string, recordIds?: string[], result?: 'success' | 'failure' | 'pending', error?: string) => string;
+    configure: (options: Partial<OperationLogConfig>) => void;
+};
+
+/**
+ * Operation log configuration
+ * @public
+ */
+export declare interface OperationLogConfig {
+    /** Maximum operations to store (default: 100) */
+    maxOperations?: number;
+    /** Enable cross-tab synchronization (default: true) */
+    enableCrossTabSync?: boolean;
+    /** Auto-sync interval in milliseconds (default: 30000) */
+    autoSyncInterval?: number;
+    /** Enable operation persistence to localStorage (default: false) */
+    enablePersistence?: boolean;
+    /** Persistence key prefix */
+    persistenceKeyPrefix?: string;
+    /** User identifier for multi-user scenarios */
+    userId?: string;
+    /** Custom operation filter */
+    operationFilter?: (operation: HSTOperation) => boolean;
+}
+
+/**
+ * Operation log snapshot for debugging
+ * @public
+ */
+export declare interface OperationLogSnapshot {
+    /** All operations in the log */
+    operations: HSTOperation[];
+    /** Current operation index in the history */
+    currentIndex: number;
+    /** Total number of operations */
+    totalOperations: number;
+    /** Number of operations that can be undone */
+    reversibleOperations: number;
+    /** Number of operations that cannot be undone */
+    irreversibleOperations: number;
+    /** Timestamp of the oldest operation */
+    oldestOperation?: Date;
+    /** Timestamp of the newest operation */
+    newestOperation?: Date;
+}
+
+/**
+ * Operation source - where the change originated
+ * @public
+ */
+export declare type OperationSource = 'user' | 'system' | 'sync' | 'undo' | 'redo';
+
+/**
+ * Pattern matching result for wildcard paths
+ * @internal
+ */
+export declare interface _PathMatchResult {
+    /** Whether the path matches the pattern */
+    matches: boolean;
+    /** Captured wildcard values */
+    captures: Record<string, string>;
+}
+
+/**
+ * Stonecrop Vue plugin
+ * @param app - The Vue app instance
+ * @param options - The plugin options
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import Stonecrop from '@stonecrop/stonecrop'
+ * import router from './router'
+ *
+ * const app = createApp(App)
+ * app.use(Stonecrop, {
+ *   router,
+ *   getMeta: async (routeContext) => {
+ *     // routeContext contains: { path, segments }
+ *     // fetch doctype meta from your API using the route context
+ *   },
+ *   autoInitializeRouter: true,
+ *   onRouterInitialized: async (registry, stonecrop) => {
+ *     // your custom initialization logic here
+ *   }
+ * })
+ * app.mount('#app')
+ * ```
+ * @public
+ */
+declare const plugin: Plugin_2;
+export default plugin;
+
+/**
+ * Register a global action function that can be used in field triggers
+ * @param name - The name of the action to register
+ * @param fn - The action function to execute when the trigger fires
+ * @public
+ */
+export declare function registerGlobalAction(name: string, fn: FieldActionFunction): void;
+
+/**
+ * Register a global XState transition action function
+ * @param name - The name of the transition action to register
+ * @param fn - The transition action function to execute
+ * @public
+ */
+export declare function registerTransitionAction(name: string, fn: TransitionActionFunction): void;
+
 /**
  * Stonecrop Registry class
  * @public
@@ -1316,12 +2002,17 @@ export declare class Registry {
      * @see {@link https://router.vuejs.org/}
      */
     readonly router?: Router;
-    constructor(router?: Router, getMeta?: (doctype: string) => DoctypeMeta | Promise<DoctypeMeta>);
     /**
-     * The getMeta function fetches doctype metadata from an API
+     * Creates a new Registry instance (singleton pattern)
+     * @param router - Optional Vue router instance for route management
+     * @param getMeta - Optional function to fetch doctype metadata from an API
+     */
+    constructor(router?: Router, getMeta?: (routeContext: RouteContext) => DoctypeMeta | Promise<DoctypeMeta>);
+    /**
+     * The getMeta function fetches doctype metadata from an API based on route context
      * @see {@link DoctypeMeta}
      */
-    getMeta?: (doctype: string) => DoctypeMeta | Promise<DoctypeMeta>;
+    getMeta?: (routeContext: RouteContext) => DoctypeMeta | Promise<DoctypeMeta>;
     /**
      * Get doctype metadata
      * @param doctype - The doctype to fetch metadata for
@@ -1331,6 +2022,17 @@ export declare class Registry {
     addDoctype(doctype: DoctypeMeta): void;
 }
 
+/**
+ * Route context passed to getMeta function
+ * @public
+ */
+export declare interface RouteContext {
+    /** The full route path (e.g., "/todo/1" or "/todo") */
+    path: string;
+    /** Path segments split by "/" (e.g., ["todo", "1"] or ["todo"]) */
+    segments: string[];
+}
+
 /**
  * Schema type for Stonecrop instances
  * @public
@@ -1347,175 +2049,380 @@ export declare type Schema = {
 export declare type SchemaTypes = FormSchema | TableSchema | FieldsetSchema;
 
 /**
- * Stonecrop Vue plugin
- * @param app - The Vue app instance
- * @param options - The plugin options
- * @example
- * ```ts
- *
- * import { createApp } from 'vue'
- * import Stonecrop from 'stonecrop'
- *
- * import App from './App.vue'
- *
- * const app = createApp(App)
- * app.use(Stonecrop, {
- *  router,
- *  components: {
- *   // register custom components
- *  },
- *  getMeta: async (doctype: string) => {
- *   // fetch doctype meta from API
- *  },
- * })
- *
- * app.mount('#app')
- * ```
- *
+ * Configure rollback behavior for a specific field trigger
+ * @param doctype - The doctype name
+ * @param fieldname - The field name
+ * @param enableRollback - Whether to enable automatic rollback for this field
  * @public
  */
-export declare const Stonecrop: Plugin_2;
+export declare function setFieldRollback(doctype: string, fieldname: string, enableRollback: boolean): void;
 
 /**
- * Stonecrop class
+ * Main Stonecrop class with HST integration and built-in Operation Log
  * @public
  */
-export declare class StonecropClass {
+export declare class Stonecrop {
+    private hstStore;
+    private _operationLogStore?;
+    private _operationLogConfig?;
+    /** The registry instance containing all doctype definitions */
+    readonly registry: Registry;
     /**
-     * The root Stonecrop instance
+     * Creates a new Stonecrop instance with HST integration
+     * @param registry - The Registry instance containing doctype definitions
+     * @param operationLogConfig - Optional configuration for the operation log
      */
-    static _root: StonecropClass;
+    constructor(registry: Registry, operationLogConfig?: Partial<OperationLogConfig>);
     /**
-     * The name of the Stonecrop instance
-     * @readonly
-     *
-     * @defaultValue 'Stonecrop'
+     * Get the operation log store (lazy initialization)
+     * @internal
      */
-    readonly name = "Stonecrop";
+    getOperationLogStore(): Store<"hst-operation-log", Pick<{
+    operations: Ref<    {
+    id: string;
+    type: HSTOperationType_2;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_2 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[], HSTOperation_2[] | {
+    id: string;
+    type: HSTOperationType_2;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_2 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[]>;
+    currentIndex: Ref<number, number>;
+    config: Ref<    {
+    maxOperations?: number | undefined;
+    enableCrossTabSync?: boolean | undefined;
+    autoSyncInterval?: number | undefined;
+    enablePersistence?: boolean | undefined;
+    persistenceKeyPrefix?: string | undefined;
+    userId?: string | undefined;
+    operationFilter?: ((operation: HSTOperation_2) => boolean) | undefined;
+    }, OperationLogConfig | {
+    maxOperations?: number | undefined;
+    enableCrossTabSync?: boolean | undefined;
+    autoSyncInterval?: number | undefined;
+    enablePersistence?: boolean | undefined;
+    persistenceKeyPrefix?: string | undefined;
+    userId?: string | undefined;
+    operationFilter?: ((operation: HSTOperation_2) => boolean) | undefined;
+    }>;
+    clientId: Ref<string, string>;
+    undoRedoState: ComputedRef<UndoRedoState_2>;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoCount: ComputedRef<number>;
+    redoCount: ComputedRef<number>;
+    configure: (options: Partial<OperationLogConfig>) => void;
+    addOperation: (operation: HSTOperationInput_2, source?: OperationSource_2) => string;
+    startBatch: () => void;
+    commitBatch: (description?: string) => string | null;
+    cancelBatch: () => void;
+    undo: (store: HSTNode) => boolean;
+    redo: (store: HSTNode) => boolean;
+    clear: () => void;
+    getOperationsFor: (doctype: string, recordId?: string) => HSTOperation_2[];
+    getSnapshot: () => OperationLogSnapshot_2;
+    markIrreversible: (operationId: string, reason: string) => void;
+    logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    }, "operations" | "clientId" | "currentIndex" | "config">, Pick<{
+    operations: Ref<    {
+    id: string;
+    type: HSTOperationType_2;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_2 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[], HSTOperation_2[] | {
+    id: string;
+    type: HSTOperationType_2;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_2 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[]>;
+    currentIndex: Ref<number, number>;
+    config: Ref<    {
+    maxOperations?: number | undefined;
+    enableCrossTabSync?: boolean | undefined;
+    autoSyncInterval?: number | undefined;
+    enablePersistence?: boolean | undefined;
+    persistenceKeyPrefix?: string | undefined;
+    userId?: string | undefined;
+    operationFilter?: ((operation: HSTOperation_2) => boolean) | undefined;
+    }, OperationLogConfig | {
+    maxOperations?: number | undefined;
+    enableCrossTabSync?: boolean | undefined;
+    autoSyncInterval?: number | undefined;
+    enablePersistence?: boolean | undefined;
+    persistenceKeyPrefix?: string | undefined;
+    userId?: string | undefined;
+    operationFilter?: ((operation: HSTOperation_2) => boolean) | undefined;
+    }>;
+    clientId: Ref<string, string>;
+    undoRedoState: ComputedRef<UndoRedoState_2>;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoCount: ComputedRef<number>;
+    redoCount: ComputedRef<number>;
+    configure: (options: Partial<OperationLogConfig>) => void;
+    addOperation: (operation: HSTOperationInput_2, source?: OperationSource_2) => string;
+    startBatch: () => void;
+    commitBatch: (description?: string) => string | null;
+    cancelBatch: () => void;
+    undo: (store: HSTNode) => boolean;
+    redo: (store: HSTNode) => boolean;
+    clear: () => void;
+    getOperationsFor: (doctype: string, recordId?: string) => HSTOperation_2[];
+    getSnapshot: () => OperationLogSnapshot_2;
+    markIrreversible: (operationId: string, reason: string) => void;
+    logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    }, "undoRedoState" | "canUndo" | "canRedo" | "undoCount" | "redoCount">, Pick<{
+    operations: Ref<    {
+    id: string;
+    type: HSTOperationType_2;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_2 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[], HSTOperation_2[] | {
+    id: string;
+    type: HSTOperationType_2;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_2 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[]>;
+    currentIndex: Ref<number, number>;
+    config: Ref<    {
+    maxOperations?: number | undefined;
+    enableCrossTabSync?: boolean | undefined;
+    autoSyncInterval?: number | undefined;
+    enablePersistence?: boolean | undefined;
+    persistenceKeyPrefix?: string | undefined;
+    userId?: string | undefined;
+    operationFilter?: ((operation: HSTOperation_2) => boolean) | undefined;
+    }, OperationLogConfig | {
+    maxOperations?: number | undefined;
+    enableCrossTabSync?: boolean | undefined;
+    autoSyncInterval?: number | undefined;
+    enablePersistence?: boolean | undefined;
+    persistenceKeyPrefix?: string | undefined;
+    userId?: string | undefined;
+    operationFilter?: ((operation: HSTOperation_2) => boolean) | undefined;
+    }>;
+    clientId: Ref<string, string>;
+    undoRedoState: ComputedRef<UndoRedoState_2>;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoCount: ComputedRef<number>;
+    redoCount: ComputedRef<number>;
+    configure: (options: Partial<OperationLogConfig>) => void;
+    addOperation: (operation: HSTOperationInput_2, source?: OperationSource_2) => string;
+    startBatch: () => void;
+    commitBatch: (description?: string) => string | null;
+    cancelBatch: () => void;
+    undo: (store: HSTNode) => boolean;
+    redo: (store: HSTNode) => boolean;
+    clear: () => void;
+    getOperationsFor: (doctype: string, recordId?: string) => HSTOperation_2[];
+    getSnapshot: () => OperationLogSnapshot_2;
+    markIrreversible: (operationId: string, reason: string) => void;
+    logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    }, "undo" | "redo" | "configure" | "addOperation" | "startBatch" | "commitBatch" | "cancelBatch" | "clear" | "getOperationsFor" | "getSnapshot" | "markIrreversible" | "logAction">>;
+    /**
+     * Initialize the HST store structure
+     */
+    private initializeHSTStore;
+    /**
+     * Setup automatic sync with Registry when doctypes are added
+     */
+    private setupRegistrySync;
+    /**
+     * Get records hash for a doctype
+     * @param doctype - The doctype to get records for
+     * @returns HST node containing records hash
+     */
+    records(doctype: string | DoctypeMeta): HSTNode;
     /**
-     * The registry is an immutable collection of doctypes
-     * @example
-     * ```ts
-     * {
-     * 	'task': {
-     * 		doctype: 'Task',
-     * 		schema: {
-     * 			title: 'string',
-     * 			description: 'string',
-     * 			...
-     * 		}
-     * 	},
-     * 	...
-     * }
-     * ```
-     * @see {@link Registry}
-     * @see {@link DoctypeMeta}
+     * Add a record to the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @param recordData - The record data
      */
-    readonly registry: Registry;
+    addRecord(doctype: string | DoctypeMeta, recordId: string, recordData: any): void;
     /**
-     * The Pinia store that manages the mutable records
+     * Get a specific record
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @returns HST node for the record or undefined
      */
-    store: ReturnType<typeof useDataStore>;
+    getRecordById(doctype: string | DoctypeMeta, recordId: string): HSTNode | undefined;
     /**
-     * @param registry - The immutable registry
-     * @param store - The mutable Pinia store
-     * @returns The Stonecrop instance with the given registry and store. If a Stonecrop instance has already been created, it returns the existing instance instead of creating a new one.
-     * @example
-     * ```ts
-     * const registry = new Registry()
-     * const store = useDataStore()
-     * const stonecrop = new Stonecrop(registry, store)
-     * ```
+     * Remove a record from the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     */
+    removeRecord(doctype: string | DoctypeMeta, recordId: string): void;
+    /**
+     * Get all record IDs for a doctype
+     * @param doctype - The doctype
+     * @returns Array of record IDs
+     */
+    getRecordIds(doctype: string | DoctypeMeta): string[];
+    /**
+     * Clear all records for a doctype
+     * @param doctype - The doctype
      */
-    constructor(registry: Registry, store: ReturnType<typeof useDataStore>);
+    clearRecords(doctype: string | DoctypeMeta): void;
     /**
-     * Sets up the Stonecrop instance with the given doctype
+     * Setup method for doctype initialization
      * @param doctype - The doctype to setup
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.setup(doctype)
-     * ```
      */
     setup(doctype: DoctypeMeta): void;
     /**
-     * Gets the meta for the given doctype
-     * @param doctype - The doctype to get meta for
-     * @returns The meta for the given doctype
-     * @throws `NotImplementedError` if the `getMeta` function is not implemented for the doctype in the registry
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * const meta = stonecrop.getMeta(doctype)
-     * ```
-     * @see {@link DoctypeMeta}
+     * Run action on doctype
+     * Executes the action and logs it to the operation log for audit tracking
+     * @param doctype - The doctype
+     * @param action - The action to run
+     * @param args - Action arguments (typically record IDs)
      */
-    getMeta(doctype: string): Promise<DoctypeMeta> | never;
+    runAction(doctype: DoctypeMeta, action: string, args?: any[]): void;
     /**
-     * Gets the records for the given doctype
-     * @param doctype - The doctype to get records for
-     * @param filters - The filters to apply to the records
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * await stonecrop.getRecords(doctype)
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * const filters = JSON.stringify({ status: 'Open' })
-     * await stonecrop.getRecords(doctype, { body: filters })
-     * ```
+     * Get records from server (maintains compatibility)
+     * @param doctype - The doctype
      */
-    getRecords(doctype: DoctypeMeta, filters?: RequestInit): Promise<void>;
+    getRecords(doctype: DoctypeMeta): Promise<void>;
     /**
-     * Gets the record for the given doctype and id
-     * @param doctype - The doctype to get record for
-     * @param id - The id of the record to get
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * await stonecrop.getRecord(doctype, 'TASK-00001')
-     * ```
+     * Get single record from server (maintains compatibility)
+     * @param doctype - The doctype
+     * @param recordId - The record ID
      */
-    getRecord(doctype: DoctypeMeta, id: string): Promise<void>;
+    getRecord(doctype: DoctypeMeta, recordId: string): Promise<void>;
     /**
-     * Runs the action for the given doctype and id
-     * @param doctype - The doctype to run action for
-     * @param action - The action to run
-     * @param id - The id(s) of the record(s) to run action on
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'create')
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'update', ['TASK-00001'])
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'delete', ['TASK-00001'])
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'merge', ['TASK-00001', 'TASK-00002'])
-     * ```
+     * Ensure doctype section exists in HST store
+     * @param slug - The doctype slug
+     */
+    private ensureDoctypeExists;
+    /**
+     * Get doctype metadata from the registry
+     * @param context - The route context
+     * @returns The doctype metadata
      */
-    runAction(doctype: DoctypeMeta, action: string, id?: string[]): void;
+    getMeta(context: RouteContext): Promise<any>;
+    /**
+     * Get the root HST store node for advanced usage
+     * @returns Root HST node
+     */
+    getStore(): HSTNode;
 }
 
-/**
- * Stonecrop composable return type
- * @public
- */
-export declare type StonecropReturn = {
-    stonecrop: Ref<StonecropClass | undefined>;
-};
-
 /**
  * Table column definition.
  * @public
@@ -1571,6 +2478,11 @@ export declare interface TableColumn {
      * @defaultValue false
      */
     pinned?: boolean;
+    /**
+     * Control whether the column can be resized by the user.
+     *
+     * @defaultValue false
+     */
     resizable?: boolean;
     /**
      * The component to use to render the cell for the column. If not provided, the table will
@@ -1862,6 +2774,53 @@ export declare type TableSchema = BaseSchema & {
     rows?: TableRow[];
 };
 
+/**
+ * Supported action types for XState transitions
+ * Can be either a transition-specific function or a string reference
+ * @public
+ */
+export declare type TransitionAction = TransitionActionFunction | FieldActionString;
+
+/**
+ * Action function for XState transition triggers
+ * Receives enhanced context with FSM state information
+ * @public
+ */
+export declare type TransitionActionFunction = (context: TransitionChangeContext) => void | Promise<void>;
+
+/**
+ * Context provided to XState transition action functions
+ * Extends FieldChangeContext with FSM-specific data
+ * @public
+ */
+export declare interface TransitionChangeContext extends FieldChangeContext {
+    /** The XState transition name that triggered this action */
+    transition: string;
+    /** Current workflow state before transition */
+    currentState?: string;
+    /** Target workflow state after transition */
+    targetState?: string;
+    /** Additional FSM context data */
+    fsmContext?: Record<string, any>;
+}
+
+/**
+ * Result of executing an XState transition action
+ * @public
+ */
+export declare interface TransitionExecutionResult {
+    /** Whether the action executed successfully */
+    success: boolean;
+    /** Error if execution failed */
+    error?: Error;
+    /** Execution time in milliseconds */
+    executionTime: number;
+    /** The action that was executed */
+    action: TransitionAction;
+    /** The transition name that was executed */
+    transition: string;
+}
+
 /**
  * Table configuration for tree-gantt view types.
  * @public
@@ -1909,24 +2868,461 @@ export declare interface TreeTableConfig extends BaseTableConfig {
     defaultTreeExpansion?: 'root' | 'branch' | 'leaf';
 }
 
-declare const useDataStore: StoreDefinition<"data", Pick<{
-records: Ref<Record<string, any>[], Record<string, any>[]>;
-record: Ref<Record<string, any>, Record<string, any>>;
-}, "records" | "record">, Pick<{
-records: Ref<Record<string, any>[], Record<string, any>[]>;
-record: Ref<Record<string, any>, Record<string, any>>;
-}, never>, Pick<{
-records: Ref<Record<string, any>[], Record<string, any>[]>;
-record: Ref<Record<string, any>, Record<string, any>>;
-}, never>>;
+/**
+ * Manually trigger an XState transition for a specific doctype/record
+ * This can be called directly when you need to execute transition actions programmatically
+ * @param doctype - The doctype name
+ * @param transition - The XState transition name to trigger
+ * @param options - Optional configuration for the transition
+ * @public
+ */
+export declare function triggerTransition(doctype: string, transition: string, options?: {
+    recordId?: string;
+    currentState?: string;
+    targetState?: string;
+    fsmContext?: Record<string, any>;
+    path?: string;
+}): Promise<any>;
 
 /**
- * Stonecrop composable
- * @param registry - An existing Stonecrop Registry instance
- * @returns The Stonecrop instance and a boolean indicating if Stonecrop is setup and ready
- * @throws Error if the Stonecrop plugin is not enabled before using the composable
+ * Undo/Redo state
+ * @public
+ */
+export declare interface UndoRedoState {
+    /** Can undo */
+    canUndo: boolean;
+    /** Can redo */
+    canRedo: boolean;
+    /** Number of operations available for undo */
+    undoCount: number;
+    /** Number of operations available for redo */
+    redoCount: number;
+    /** Current operation index */
+    currentIndex: number;
+}
+
+/**
+ * Composable for operation log management
+ * Provides easy access to undo/redo functionality and operation history
+ *
+ * @param config - Optional configuration for the operation log
+ * @returns Operation log interface
+ *
+ * @example
+ * ```typescript
+ * const { undo, redo, canUndo, canRedo, operations, configure } = useOperationLog()
+ *
+ * // Configure the log
+ * configure({
+ *   maxOperations: 50,
+ *   enableCrossTabSync: true,
+ *   enablePersistence: true
+ * })
+ *
+ * // Undo/redo
+ * await undo(hstStore)
+ * await redo(hstStore)
+ * ```
+ *
+ * @public
+ */
+export declare function useOperationLog(config?: Partial<OperationLogConfig>): {
+    operations: Ref<    {
+    id: string;
+    type: HSTOperationType_3;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_3 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[], HSTOperation_3[] | {
+    id: string;
+    type: HSTOperationType_3;
+    path: string;
+    fieldname: string;
+    beforeValue: any;
+    afterValue: any;
+    doctype: string;
+    recordId?: string | undefined;
+    timestamp: Date;
+    source?: OperationSource_3 | undefined;
+    reversible: boolean;
+    irreversibleReason?: string | undefined;
+    transition?: string | undefined;
+    currentState?: string | undefined;
+    targetState?: string | undefined;
+    actionName?: string | undefined;
+    actionRecordIds?: string[] | undefined;
+    actionResult?: "success" | "failure" | "pending" | undefined;
+    actionError?: string | undefined;
+    userId?: string | undefined;
+    metadata?: Record<string, any> | undefined;
+    parentOperationId?: string | undefined;
+    childOperationIds?: string[] | undefined;
+    }[]>;
+    currentIndex: Ref<number, number>;
+    undoRedoState: ComputedRef<UndoRedoState_3>;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoCount: ComputedRef<number>;
+    redoCount: ComputedRef<number>;
+    undo: (hstStore: HSTNode) => boolean;
+    redo: (hstStore: HSTNode) => boolean;
+    startBatch: () => void;
+    commitBatch: (description?: string) => string | null;
+    cancelBatch: () => void;
+    clear: () => void;
+    getOperationsFor: (doctype: string, recordId?: string) => HSTOperation_3[];
+    getSnapshot: () => OperationLogSnapshot_3;
+    markIrreversible: (operationId: string, reason: string) => void;
+    logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    configure: (options: Partial<OperationLogConfig>) => void;
+};
+
+/**
+ * Global HST Operation Log Store
+ * Tracks all mutations with full metadata for undo/redo, sync, and audit
+ *
+ * @public
+ */
+export declare const useOperationLogStore: StoreDefinition<"hst-operation-log", Pick<{
+operations: Ref<    {
+id: string;
+type: HSTOperationType_3;
+path: string;
+fieldname: string;
+beforeValue: any;
+afterValue: any;
+doctype: string;
+recordId?: string | undefined;
+timestamp: Date;
+source?: OperationSource | undefined;
+reversible: boolean;
+irreversibleReason?: string | undefined;
+transition?: string | undefined;
+currentState?: string | undefined;
+targetState?: string | undefined;
+actionName?: string | undefined;
+actionRecordIds?: string[] | undefined;
+actionResult?: "success" | "failure" | "pending" | undefined;
+actionError?: string | undefined;
+userId?: string | undefined;
+metadata?: Record<string, any> | undefined;
+parentOperationId?: string | undefined;
+childOperationIds?: string[] | undefined;
+}[], HSTOperation[] | {
+id: string;
+type: HSTOperationType_3;
+path: string;
+fieldname: string;
+beforeValue: any;
+afterValue: any;
+doctype: string;
+recordId?: string | undefined;
+timestamp: Date;
+source?: OperationSource | undefined;
+reversible: boolean;
+irreversibleReason?: string | undefined;
+transition?: string | undefined;
+currentState?: string | undefined;
+targetState?: string | undefined;
+actionName?: string | undefined;
+actionRecordIds?: string[] | undefined;
+actionResult?: "success" | "failure" | "pending" | undefined;
+actionError?: string | undefined;
+userId?: string | undefined;
+metadata?: Record<string, any> | undefined;
+parentOperationId?: string | undefined;
+childOperationIds?: string[] | undefined;
+}[]>;
+currentIndex: Ref<number, number>;
+config: Ref<    {
+maxOperations?: number | undefined;
+enableCrossTabSync?: boolean | undefined;
+autoSyncInterval?: number | undefined;
+enablePersistence?: boolean | undefined;
+persistenceKeyPrefix?: string | undefined;
+userId?: string | undefined;
+operationFilter?: ((operation: HSTOperation) => boolean) | undefined;
+}, OperationLogConfig | {
+maxOperations?: number | undefined;
+enableCrossTabSync?: boolean | undefined;
+autoSyncInterval?: number | undefined;
+enablePersistence?: boolean | undefined;
+persistenceKeyPrefix?: string | undefined;
+userId?: string | undefined;
+operationFilter?: ((operation: HSTOperation) => boolean) | undefined;
+}>;
+clientId: Ref<string, string>;
+undoRedoState: ComputedRef<UndoRedoState>;
+canUndo: ComputedRef<boolean>;
+canRedo: ComputedRef<boolean>;
+undoCount: ComputedRef<number>;
+redoCount: ComputedRef<number>;
+configure: (options: Partial<OperationLogConfig>) => void;
+addOperation: (operation: HSTOperationInput, source?: OperationSource) => string;
+startBatch: () => void;
+commitBatch: (description?: string) => string | null;
+cancelBatch: () => void;
+undo: (store: HSTNode) => boolean;
+redo: (store: HSTNode) => boolean;
+clear: () => void;
+getOperationsFor: (doctype: string, recordId?: string) => HSTOperation[];
+getSnapshot: () => OperationLogSnapshot;
+markIrreversible: (operationId: string, reason: string) => void;
+logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+}, "operations" | "clientId" | "currentIndex" | "config">, Pick<{
+operations: Ref<    {
+id: string;
+type: HSTOperationType_3;
+path: string;
+fieldname: string;
+beforeValue: any;
+afterValue: any;
+doctype: string;
+recordId?: string | undefined;
+timestamp: Date;
+source?: OperationSource | undefined;
+reversible: boolean;
+irreversibleReason?: string | undefined;
+transition?: string | undefined;
+currentState?: string | undefined;
+targetState?: string | undefined;
+actionName?: string | undefined;
+actionRecordIds?: string[] | undefined;
+actionResult?: "success" | "failure" | "pending" | undefined;
+actionError?: string | undefined;
+userId?: string | undefined;
+metadata?: Record<string, any> | undefined;
+parentOperationId?: string | undefined;
+childOperationIds?: string[] | undefined;
+}[], HSTOperation[] | {
+id: string;
+type: HSTOperationType_3;
+path: string;
+fieldname: string;
+beforeValue: any;
+afterValue: any;
+doctype: string;
+recordId?: string | undefined;
+timestamp: Date;
+source?: OperationSource | undefined;
+reversible: boolean;
+irreversibleReason?: string | undefined;
+transition?: string | undefined;
+currentState?: string | undefined;
+targetState?: string | undefined;
+actionName?: string | undefined;
+actionRecordIds?: string[] | undefined;
+actionResult?: "success" | "failure" | "pending" | undefined;
+actionError?: string | undefined;
+userId?: string | undefined;
+metadata?: Record<string, any> | undefined;
+parentOperationId?: string | undefined;
+childOperationIds?: string[] | undefined;
+}[]>;
+currentIndex: Ref<number, number>;
+config: Ref<    {
+maxOperations?: number | undefined;
+enableCrossTabSync?: boolean | undefined;
+autoSyncInterval?: number | undefined;
+enablePersistence?: boolean | undefined;
+persistenceKeyPrefix?: string | undefined;
+userId?: string | undefined;
+operationFilter?: ((operation: HSTOperation) => boolean) | undefined;
+}, OperationLogConfig | {
+maxOperations?: number | undefined;
+enableCrossTabSync?: boolean | undefined;
+autoSyncInterval?: number | undefined;
+enablePersistence?: boolean | undefined;
+persistenceKeyPrefix?: string | undefined;
+userId?: string | undefined;
+operationFilter?: ((operation: HSTOperation) => boolean) | undefined;
+}>;
+clientId: Ref<string, string>;
+undoRedoState: ComputedRef<UndoRedoState>;
+canUndo: ComputedRef<boolean>;
+canRedo: ComputedRef<boolean>;
+undoCount: ComputedRef<number>;
+redoCount: ComputedRef<number>;
+configure: (options: Partial<OperationLogConfig>) => void;
+addOperation: (operation: HSTOperationInput, source?: OperationSource) => string;
+startBatch: () => void;
+commitBatch: (description?: string) => string | null;
+cancelBatch: () => void;
+undo: (store: HSTNode) => boolean;
+redo: (store: HSTNode) => boolean;
+clear: () => void;
+getOperationsFor: (doctype: string, recordId?: string) => HSTOperation[];
+getSnapshot: () => OperationLogSnapshot;
+markIrreversible: (operationId: string, reason: string) => void;
+logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+}, "undoRedoState" | "canUndo" | "canRedo" | "undoCount" | "redoCount">, Pick<{
+operations: Ref<    {
+id: string;
+type: HSTOperationType_3;
+path: string;
+fieldname: string;
+beforeValue: any;
+afterValue: any;
+doctype: string;
+recordId?: string | undefined;
+timestamp: Date;
+source?: OperationSource | undefined;
+reversible: boolean;
+irreversibleReason?: string | undefined;
+transition?: string | undefined;
+currentState?: string | undefined;
+targetState?: string | undefined;
+actionName?: string | undefined;
+actionRecordIds?: string[] | undefined;
+actionResult?: "success" | "failure" | "pending" | undefined;
+actionError?: string | undefined;
+userId?: string | undefined;
+metadata?: Record<string, any> | undefined;
+parentOperationId?: string | undefined;
+childOperationIds?: string[] | undefined;
+}[], HSTOperation[] | {
+id: string;
+type: HSTOperationType_3;
+path: string;
+fieldname: string;
+beforeValue: any;
+afterValue: any;
+doctype: string;
+recordId?: string | undefined;
+timestamp: Date;
+source?: OperationSource | undefined;
+reversible: boolean;
+irreversibleReason?: string | undefined;
+transition?: string | undefined;
+currentState?: string | undefined;
+targetState?: string | undefined;
+actionName?: string | undefined;
+actionRecordIds?: string[] | undefined;
+actionResult?: "success" | "failure" | "pending" | undefined;
+actionError?: string | undefined;
+userId?: string | undefined;
+metadata?: Record<string, any> | undefined;
+parentOperationId?: string | undefined;
+childOperationIds?: string[] | undefined;
+}[]>;
+currentIndex: Ref<number, number>;
+config: Ref<    {
+maxOperations?: number | undefined;
+enableCrossTabSync?: boolean | undefined;
+autoSyncInterval?: number | undefined;
+enablePersistence?: boolean | undefined;
+persistenceKeyPrefix?: string | undefined;
+userId?: string | undefined;
+operationFilter?: ((operation: HSTOperation) => boolean) | undefined;
+}, OperationLogConfig | {
+maxOperations?: number | undefined;
+enableCrossTabSync?: boolean | undefined;
+autoSyncInterval?: number | undefined;
+enablePersistence?: boolean | undefined;
+persistenceKeyPrefix?: string | undefined;
+userId?: string | undefined;
+operationFilter?: ((operation: HSTOperation) => boolean) | undefined;
+}>;
+clientId: Ref<string, string>;
+undoRedoState: ComputedRef<UndoRedoState>;
+canUndo: ComputedRef<boolean>;
+canRedo: ComputedRef<boolean>;
+undoCount: ComputedRef<number>;
+redoCount: ComputedRef<number>;
+configure: (options: Partial<OperationLogConfig>) => void;
+addOperation: (operation: HSTOperationInput, source?: OperationSource) => string;
+startBatch: () => void;
+commitBatch: (description?: string) => string | null;
+cancelBatch: () => void;
+undo: (store: HSTNode) => boolean;
+redo: (store: HSTNode) => boolean;
+clear: () => void;
+getOperationsFor: (doctype: string, recordId?: string) => HSTOperation[];
+getSnapshot: () => OperationLogSnapshot;
+markIrreversible: (operationId: string, reason: string) => void;
+logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+}, "undo" | "redo" | "configure" | "addOperation" | "startBatch" | "commitBatch" | "cancelBatch" | "clear" | "getOperationsFor" | "getSnapshot" | "markIrreversible" | "logAction">>;
+
+/**
+ * Unified Stonecrop composable - handles both general operations and HST reactive integration
+ *
+ * @param options - Configuration options for the composable
+ * @returns Stonecrop instance and optional HST integration utilities
+ * @public
+ */
+export declare function useStonecrop(): BaseStonecropReturn | HSTStonecropReturn;
+
+/**
+ * Unified Stonecrop composable with HST integration for a specific doctype and record
+ *
+ * @param options - Configuration with doctype and optional recordId
+ * @returns Stonecrop instance with full HST integration utilities
+ * @public
+ */
+export declare function useStonecrop(options: {
+    registry?: Registry;
+    doctype: DoctypeMeta;
+    recordId?: string;
+}): HSTStonecropReturn;
+
+/**
+ * Keyboard shortcut handler for undo/redo
+ * Automatically binds Ctrl+Z (undo) and Ctrl+Shift+Z/Ctrl+Y (redo) using VueUse
+ *
+ * @param hstStore - The HST store to operate on
+ * @param enabled - Whether shortcuts are enabled (default: true)
+ *
+ * @example
+ * ```typescript
+ * import { onMounted } from 'vue'
+ *
+ * const stonecrop = useStonecrop({ doctype, recordId })
+ * useUndoRedoShortcuts(stonecrop.hstStore)
+ * ```
+ *
+ * @public
+ */
+export declare function useUndoRedoShortcuts(hstStore: HSTNode, enabled?: boolean): void;
+
+/**
+ * Batch operation helper
+ * Wraps a function execution in a batch operation
+ *
+ * @param fn - The function to execute within a batch
+ * @param description - Optional description for the batch
+ * @returns The batch operation ID
+ *
+ * @example
+ * ```typescript
+ * const { withBatch } = useOperationLog()
+ *
+ * const batchId = await withBatch(() => {
+ *   hstStore.set('task.123.title', 'New Title')
+ *   hstStore.set('task.123.status', 'active')
+ *   hstStore.set('task.123.priority', 'high')
+ * }, 'Update task details')
+ * ```
+ *
  * @public
  */
-export declare function useStonecrop(registry?: Registry): StonecropReturn;
+export declare function withBatch<T>(fn: () => T | Promise<T>, description?: string): Promise<string | null>;
 
 export { }