@stonecrop/stonecrop 0.11.6 → 0.11.8

package/dist/{composables → src/composables}/lazy-link.js

@@ -59,7 +59,7 @@ export function useLazyLink(doctype, recordId, linkFieldname) {
             return await fn(stonecropInstance, getLinkPath(), hstStore);
         }
         catch (err) {
-            throw new Error(`Custom handler failed: ${err instanceof Error ? err.message : String(err)}`);
+            throw new Error(`Custom handler failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
         }
     };
     /**

package/dist/src/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,kBAAkB,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,OAAO,MAAM,WAAW,CAAA;AAE/B,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC5B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAA;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAa;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IAE/C;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc,CAAqE;IAE3F;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB,CAAgB;IAE3C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAExB;;;;OAIG;gBACS,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IASjG;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAEpE;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO;IAuB3B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,WAAW,EAAE;IA4FrE;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAmDrB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAqD5D;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI7C;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAUvF;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAwBtG;;;OAGG;IACH,OAAO,CAAC,oBAAoB;CAgC5B"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,kBAAkB,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,OAAO,MAAM,WAAW,CAAA;AAE/B,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC5B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAA;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAa;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAK;IAE/C;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc,CAAqE;IAE3F;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB,CAAgB;IAE3C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAExB;;;;OAIG;gBACS,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IASjG;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAEpE;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,OAAO;IAuB3B;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,WAAW,EAAE;IA2FrE;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAkDrB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IA6BxB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAqD5D;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAI7C;;;;;;;;;;;;;OAaG;IACH,kBAAkB,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAUvF;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,CAAC,eAAe,GAAG;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IAwBtG;;;OAGG;IACH,OAAO,CAAC,oBAAoB;CAgC5B"}

package/dist/{registry.js → src/registry.js}

@@ -160,7 +160,6 @@ export default class Registry {
                 }
                 else {
                     // One relationship — embed form schema
-                    // TODO: remove assertion once resolved link output has a dedicated type separate from input schema
                     resolvedFields.push({
                         ...fieldRest,
                         label: fieldRest.label || field.fieldname,
@@ -207,7 +206,6 @@ export default class Registry {
                     resolved.push(this.buildTableConfig({ ...fieldRest, label: fieldRest.label || field.fieldname }, childSchema, link.component));
                 }
                 else {
-                    // TODO: remove assertion once resolved link output has a dedicated type separate from input schema
                     resolved.push({
                         ...fieldRest,
                         label: fieldRest.label || field.fieldname,

package/dist/src/stonecrop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stonecrop.d.ts","sourceRoot":"","sources":["../../src/stonecrop.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stonecrop.d.ts","sourceRoot":"","sources":["../../src/stonecrop.ts"],"names":[],"mappings":"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"}

package/dist/src/stonecrop.js

@@ -0,0 +1,565 @@
+import { reactive } from 'vue';
+import { getGlobalTriggerEngine } from './field-triggers';
+import { createHST } from './stores/hst';
+import { useOperationLogStore } from './stores/operation-log';
+/**
+ * Main Stonecrop class with HST integration and built-in Operation Log
+ * @public
+ */
+export class Stonecrop {
+    /**
+     * Singleton instance of Stonecrop. Only one Stonecrop instance can exist
+     * per application, ensuring consistent HST state and registry access.
+     * Subsequent constructor calls return this instance instead of creating new ones.
+     * @internal
+     */
+    static _root;
+    /** The HST store instance for reactive state management */
+    hstStore;
+    _operationLogStore;
+    _operationLogConfig;
+    _client;
+    /** The registry instance containing all doctype definitions */
+    registry;
+    /**
+     * Creates a new Stonecrop instance with HST integration (singleton pattern)
+     * @param registry - The Registry instance containing doctype definitions
+     * @param operationLogConfig - Optional configuration for the operation log
+     * @param options - Options including the data client (can be set later via setClient)
+     */
+    constructor(registry, operationLogConfig, options) {
+        if (Stonecrop._root) {
+            return Stonecrop._root;
+        }
+        Stonecrop._root = this;
+        this.registry = registry;
+        // Store config for lazy initialization
+        this._operationLogConfig = operationLogConfig;
+        // Store data client (can be set later via setClient)
+        this._client = options?.client;
+        // Initialize HST store with auto-sync to Registry
+        this.initializeHSTStore();
+        this.setupRegistrySync();
+    }
+    /**
+     * Set the data client for fetching doctype metadata and records.
+     * Use this for deferred configuration in Nuxt/Vue plugin setups.
+     *
+     * @param client - DataClient implementation (e.g., StonecropClient from \@stonecrop/graphql-client)
+     *
+     * @example
+     * ```ts
+     * const { setClient } = useStonecropRegistry()
+     * const client = new StonecropClient({ endpoint: '/graphql' })
+     * setClient(client)
+     * ```
+     */
+    setClient(client) {
+        this._client = client;
+    }
+    /**
+     * Get the current data client
+     * @returns The DataClient instance or undefined if not set
+     */
+    getClient() {
+        return this._client;
+    }
+    /**
+     * Get the operation log store (lazy initialization)
+     * @internal
+     */
+    getOperationLogStore() {
+        if (!this._operationLogStore) {
+            this._operationLogStore = useOperationLogStore();
+            if (this._operationLogConfig) {
+                this._operationLogStore.configure(this._operationLogConfig);
+            }
+        }
+        return this._operationLogStore;
+    }
+    /**
+     * Initialize the HST store structure
+     */
+    initializeHSTStore() {
+        const initialStoreStructure = {};
+        // Auto-populate from existing Registry doctypes
+        Object.keys(this.registry.registry).forEach(doctypeSlug => {
+            initialStoreStructure[doctypeSlug] = {};
+        });
+        // Wrap the store in Vue's reactive() for automatic change detection
+        // This enables Vue computed properties to track HST store changes
+        this.hstStore = createHST(reactive(initialStoreStructure), 'StonecropStore');
+    }
+    /**
+     * Setup automatic sync with Registry when doctypes are added
+     */
+    setupRegistrySync() {
+        // Extend Registry.addDoctype to auto-create HST store sections
+        const originalAddDoctype = this.registry.addDoctype.bind(this.registry);
+        this.registry.addDoctype = (doctype) => {
+            // Call original method
+            originalAddDoctype(doctype);
+            // Auto-create HST store section for new doctype
+            if (!this.hstStore.has(doctype.slug)) {
+                this.hstStore.set(doctype.slug, {});
+            }
+        };
+    }
+    /**
+     * Get records hash for a doctype
+     * @param doctype - The doctype to get records for
+     * @returns HST node containing records hash
+     */
+    records(doctype) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        return this.hstStore.getNode(slug);
+    }
+    /**
+     * Add a record to the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @param recordData - The record data
+     */
+    addRecord(doctype, recordId, recordData) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Store raw record data - let HST handle wrapping with proper hierarchy
+        this.hstStore.set(`${slug}.${recordId}`, recordData);
+    }
+    /**
+     * Get a specific record
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @returns HST node for the record or undefined
+     */
+    getRecordById(doctype, recordId) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // First check if the record exists
+        const recordExists = this.hstStore.has(`${slug}.${recordId}`);
+        if (!recordExists) {
+            return undefined;
+        }
+        // Check if the actual value is undefined (i.e., record was removed)
+        const recordValue = this.hstStore.get(`${slug}.${recordId}`);
+        if (recordValue === undefined) {
+            return undefined;
+        }
+        // Use getNode to get the properly wrapped HST node with correct ancestor relationships
+        return this.hstStore.getNode(`${slug}.${recordId}`);
+    }
+    /**
+     * Remove a record from the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     */
+    removeRecord(doctype, recordId) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Remove the specific record directly by setting to undefined
+        if (this.hstStore.has(`${slug}.${recordId}`)) {
+            this.hstStore.set(`${slug}.${recordId}`, undefined);
+        }
+    }
+    /**
+     * Get all record IDs for a doctype
+     * @param doctype - The doctype
+     * @returns Array of record IDs
+     */
+    getRecordIds(doctype) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        const doctypeNode = this.hstStore.get(slug);
+        if (!doctypeNode || typeof doctypeNode !== 'object') {
+            return [];
+        }
+        return Object.keys(doctypeNode).filter(key => doctypeNode[key] !== undefined);
+    }
+    /**
+     * Clear all records for a doctype
+     * @param doctype - The doctype
+     */
+    clearRecords(doctype) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Get all record IDs and remove them
+        const recordIds = this.getRecordIds(slug);
+        recordIds.forEach(recordId => {
+            this.hstStore.set(`${slug}.${recordId}`, undefined);
+        });
+    }
+    /**
+     * Setup method for doctype initialization
+     * @param doctype - The doctype to setup
+     */
+    setup(doctype) {
+        // Ensure doctype exists in store
+        this.ensureDoctypeExists(doctype.slug);
+    }
+    /**
+     * 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)
+     */
+    runAction(doctype, action, args) {
+        const registry = this.registry.registry[doctype.slug];
+        const actions = registry?.actions?.get(action);
+        const recordIds = Array.isArray(args) ? args.filter((arg) => typeof arg === 'string') : undefined;
+        const recordId = recordIds?.[0];
+        // Check if workflow is ready (all blocked links have data)
+        const workflowStatus = recordId ? this.isWorkflowReady(doctype, recordId) : { ready: true };
+        if (!workflowStatus.ready) {
+            const opLogStore = this.getOperationLogStore();
+            opLogStore.logAction(doctype.doctype, action, recordIds, 'failure', `BLOCKED: missing data for links: ${workflowStatus.blockedLinks?.join(', ')}`);
+            throw new Error(`Workflow blocked: missing data for links: ${workflowStatus.blockedLinks?.join(', ')}`);
+        }
+        // Log action execution start
+        const opLogStore = this.getOperationLogStore();
+        let actionResult = 'success';
+        let actionError;
+        try {
+            // Execute action functions
+            if (actions && actions.length > 0) {
+                const engine = getGlobalTriggerEngine();
+                actions.forEach(actionStr => {
+                    try {
+                        const actionFn = engine.getAction(actionStr);
+                        if (!actionFn)
+                            throw new Error(`Action "${actionStr}" is not registered in FieldTriggerEngine`);
+                        const context = {
+                            path: `${doctype.slug}.${recordIds?.[0] ?? ''}`,
+                            fieldname: action,
+                            beforeValue: undefined,
+                            afterValue: args,
+                            operation: 'set',
+                            doctype: doctype.doctype,
+                            recordId: recordId,
+                            timestamp: new Date(),
+                        };
+                        void actionFn(context);
+                    }
+                    catch (error) {
+                        actionResult = 'failure';
+                        actionError = error instanceof Error ? error.message : 'Unknown error';
+                        throw error;
+                    }
+                });
+            }
+        }
+        catch {
+            // Error already set in inner catch
+        }
+        finally {
+            // Log the action execution to operation log
+            opLogStore.logAction(doctype.doctype, action, recordIds, actionResult, actionError);
+        }
+    }
+    /**
+     * Get the effective blockWorkflows value for a link.
+     * Returns true if blockWorkflows is explicitly true, or if it's absent and fetch method is 'sync'.
+     * @param link - The link declaration
+     * @returns Whether workflows should be blocked until this link is loaded
+     */
+    getEffectiveBlockWorkflows(link) {
+        if (link.blockWorkflows !== undefined) {
+            return link.blockWorkflows;
+        }
+        // TODO: For custom fetch handlers, this returns false (not blocking), but the custom handler
+        // may still be invoked by useLazyLink. Future: custom handlers should be able to declare they
+        // satisfy blockWorkflows, or validation should reject custom + blockWorkflows: true.
+        // See: relationships.md Phase 6 "Open Question: blockWorkflows + custom fetch"
+        return link.fetch?.method === 'sync';
+    }
+    /**
+     * Check if workflow actions are ready to run (all required link data is loaded).
+     * A link's data is considered loaded if it exists in HST at `slug.recordId.linkname`.
+     * @param doctype - The doctype to check
+     * @param recordId - The record ID
+     * @returns Object with `ready: true` if all blocked links are loaded, or `ready: false` with `blockedLinks` array
+     */
+    isWorkflowReady(doctype, recordId) {
+        // New records don't block workflows - they haven't been saved yet
+        if (recordId === 'new') {
+            return { ready: true };
+        }
+        const links = this.registry.getDescendantLinks(doctype.slug);
+        const blockedLinks = [];
+        for (const link of links) {
+            if (this.getEffectiveBlockWorkflows(link)) {
+                const linkPath = `${doctype.slug}.${recordId}.${link.fieldname}`;
+                if (!this.hstStore.has(linkPath)) {
+                    blockedLinks.push(link.fieldname);
+                }
+            }
+        }
+        if (blockedLinks.length > 0) {
+            return { ready: false, blockedLinks };
+        }
+        return { ready: true };
+    }
+    /**
+     * Get records from server using the configured data client.
+     * @param doctype - The doctype
+     * @throws Error if no data client has been configured
+     */
+    async getRecords(doctype) {
+        if (!this._client) {
+            throw new Error('No data client configured. Call setClient() with a DataClient implementation ' +
+                '(e.g., StonecropClient from @stonecrop/graphql-client) before fetching records.');
+        }
+        const records = await this._client.getRecords(doctype);
+        // Store each record in HST
+        records.forEach(record => {
+            if (record.id) {
+                this.addRecord(doctype, record.id, record);
+            }
+        });
+    }
+    /**
+     * Get single record from server using the configured data client.
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @throws Error if no data client has been configured
+     */
+    async getRecord(doctype, recordId) {
+        if (!this._client) {
+            throw new Error('No data client configured. Call setClient() with a DataClient implementation ' +
+                '(e.g., StonecropClient from @stonecrop/graphql-client) before fetching records.');
+        }
+        const record = await this._client.getRecord(doctype, recordId);
+        if (record) {
+            this.addRecord(doctype, recordId, record);
+        }
+    }
+    /**
+     * Dispatch an action to the server via the configured data client.
+     * All state changes flow through this single mutation endpoint.
+     *
+     * @param doctype - The doctype
+     * @param action - Action name to execute (e.g., 'SUBMIT', 'APPROVE', 'save')
+     * @param args - Action arguments (typically record ID and/or form data)
+     * @returns Action result with success status, response data, and any error
+     * @throws Error if no data client has been configured
+     */
+    async dispatchAction(doctype, action, args) {
+        if (!this._client) {
+            throw new Error('No data client configured. Call setClient() with a DataClient implementation ' +
+                '(e.g., StonecropClient from @stonecrop/graphql-client) before dispatching actions.');
+        }
+        return this._client.runAction(doctype, action, args);
+    }
+    /**
+     * Ensure doctype section exists in HST store
+     * @param slug - The doctype slug
+     */
+    ensureDoctypeExists(slug) {
+        if (!this.hstStore.has(slug)) {
+            this.hstStore.set(slug, {});
+        }
+    }
+    /**
+     * Get doctype metadata from the registry
+     * @param context - The route context
+     * @returns The doctype metadata
+     */
+    async getMeta(context) {
+        if (!this.registry.getMeta) {
+            throw new Error('No getMeta function provided to Registry');
+        }
+        return await this.registry.getMeta(context);
+    }
+    /**
+     * Get the root HST store node for advanced usage
+     * @returns Root HST node
+     */
+    getStore() {
+        return this.hstStore;
+    }
+    /**
+     * Determine the current workflow state for a record.
+     *
+     * Reads the record's `status` field from the HST store. If the field is absent or
+     * empty the doctype's declared `workflow.initial` state is used as the fallback,
+     * giving callers a reliable state name without having to duplicate that logic.
+     *
+     * @param doctype - The doctype slug or Doctype instance
+     * @param recordId - The record identifier
+     * @returns The current state name, or an empty string if the doctype has no workflow
+     *
+     * @public
+     */
+    getRecordState(doctype, recordId) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        const meta = this.registry.getDoctype(slug);
+        if (!meta?.workflow)
+            return '';
+        const record = this.getRecordById(slug, recordId);
+        const status = record?.get('status');
+        // Handle both XState format and WorkflowMeta format
+        const workflow = meta.workflow;
+        let initialState;
+        if (Array.isArray(workflow.states)) {
+            // WorkflowMeta format: states is a string array
+            initialState = workflow.states[0] ?? '';
+        }
+        else {
+            // XState format: states is an object, use initial or first key
+            initialState =
+                typeof workflow.initial === 'string'
+                    ? workflow.initial
+                    : Object.keys(workflow.states ?? {})[0] ?? '';
+        }
+        return status || initialState;
+    }
+    /**
+     * Collect a record payload with all nested doctype fields from HST
+     * @param doctype - The doctype metadata
+     * @param recordId - The record ID to collect
+     * @returns The complete record payload ready for API submission
+     * @public
+     */
+    collectRecordPayload(doctype, recordId) {
+        const recordPath = `${doctype.slug}.${recordId}`;
+        const recordData = this.hstStore.get(recordPath) || {};
+        const payload = { ...recordData };
+        // Collect nested data from links
+        if (doctype.links) {
+            for (const [fieldname, link] of Object.entries(doctype.links)) {
+                const fieldPath = `${recordPath}.${fieldname}`;
+                const isMany = link.cardinality === 'noneOrMany' || link.cardinality === 'atLeastOne';
+                if (isMany) {
+                    const arrayData = this.hstStore.get(fieldPath);
+                    if (Array.isArray(arrayData)) {
+                        payload[fieldname] = arrayData;
+                    }
+                }
+                else {
+                    const targetDoctype = this.registry.getDoctype(link.target);
+                    if (targetDoctype?.links) {
+                        payload[fieldname] = this.collectNestedData(fieldPath, targetDoctype);
+                    }
+                    else {
+                        payload[fieldname] = this.hstStore.get(fieldPath) || {};
+                    }
+                }
+            }
+        }
+        return payload;
+    }
+    /**
+     * Scaffold empty descendant records from defaults for all descendant links.
+     *
+     * Initializes all scalar and link fields at their HST paths with default values.
+     * For new records, call this after setting up the doctype to ensure all paths exist.
+     *
+     * @param path - HST path (e.g., "customer.new")
+     * @param doctype - The doctype to initialize
+     * @public
+     */
+    initializeNestedData(path, doctype) {
+        const slug = doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Resolve schema and initialize with defaults
+        const resolvedSchema = this.registry.resolveSchema(doctype);
+        const record = this.registry.initializeRecord(resolvedSchema);
+        // Ensure the ancestor path exists in HST before setting descendant fields
+        const existingData = this.hstStore.get(path);
+        if (!existingData) {
+            this.hstStore.set(path, {}, 'system');
+        }
+        // Store each field at its own HST path
+        for (const [key, value] of Object.entries(record)) {
+            this.hstStore.set(`${path}.${key}`, value, 'system');
+        }
+    }
+    /**
+     * Fetch a record and its nested data from the server.
+     *
+     * Calls `_client.getRecord()` with nested sub-selections and stores each scalar field at its own HST path
+     * (`slug.recordId.fieldname`), descendants at the link-level path (`slug.recordId.linkname`).
+     *
+     * @param path - HST path (e.g., "recipe.r1")
+     * @param doctype - The doctype to fetch
+     * @param recordId - Record ID to fetch
+     * @param options - Query options (includeNested to control which links are fetched)
+     * @throws Error with code `"CLIENT_REQUIRED"` if no data client is configured
+     * @throws Error with code `"RECORD_NOT_FOUND"` if the server returns null
+     * @public
+     */
+    async fetchNestedData(path, doctype, recordId, options) {
+        if (!this._client) {
+            throw createCodedError('No data client configured. Call setClient() with a DataClient implementation ' +
+                '(e.g., StonecropClient from @stonecrop/graphql-client) before fetching records.', 'CLIENT_REQUIRED');
+        }
+        const record = await this._client.getRecord({ name: doctype.doctype }, recordId, {
+            includeNested: options?.includeNested ?? true,
+        });
+        if (!record) {
+            throw createCodedError(`Record not found: ${doctype.doctype} ${recordId}`, 'RECORD_NOT_FOUND');
+        }
+        // Store each scalar field at its own HST path, descendants at link-level path
+        const slug = doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Ensure the ancestor path exists in HST before setting descendant fields
+        const existingData = this.hstStore.get(`${slug}.${recordId}`);
+        if (!existingData) {
+            this.hstStore.set(`${slug}.${recordId}`, {}, 'system');
+        }
+        for (const [key, value] of Object.entries(record)) {
+            this.hstStore.set(`${slug}.${recordId}.${key}`, value, 'system');
+        }
+    }
+    /**
+     * Recursively collect nested data from HST
+     * @param basePath - The base path in HST (e.g., "customer.123.address")
+     * @param doctype - The doctype whose links drive the recursive traversal
+     * @returns The collected data object
+     */
+    collectNestedData(basePath, doctype) {
+        const data = this.hstStore.get(basePath) || {};
+        const payload = { ...data };
+        if (!doctype.links)
+            return payload;
+        for (const [fieldname, link] of Object.entries(doctype.links)) {
+            const fieldPath = `${basePath}.${fieldname}`;
+            const isMany = link.cardinality === 'noneOrMany' || link.cardinality === 'atLeastOne';
+            if (isMany) {
+                const arrayData = this.hstStore.get(fieldPath);
+                if (Array.isArray(arrayData)) {
+                    payload[fieldname] = arrayData;
+                }
+            }
+            else {
+                const targetDoctype = this.registry.getDoctype(link.target);
+                if (targetDoctype?.links) {
+                    payload[fieldname] = this.collectNestedData(fieldPath, targetDoctype);
+                }
+                else {
+                    payload[fieldname] = this.hstStore.get(fieldPath) || {};
+                }
+            }
+        }
+        return payload;
+    }
+}
+/**
+ * Returns the global Stonecrop singleton instance, or `undefined` if no
+ * instance has been created yet.
+ *
+ * Use this when you need the Stonecrop instance outside a Vue component
+ * context (e.g., in workflow action handlers, plugin setup code, or
+ * non-component utilities). Inside a component, prefer `useStonecrop()`.
+ *
+ * @public
+ */
+export function getStonecrop() {
+    return Stonecrop._root;
+}
+function createCodedError(message, code) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+}

package/dist/{stores → src/stores}/hst.js

@@ -91,7 +91,7 @@ class HSTProxy {
             get(hst, prop) {
                 // Return HST methods directly
                 if (prop in hst)
-                    return hst[prop];
+                    return Reflect.get(hst, prop);
                 // Handle property access - return tree nodes for navigation
                 const path = String(prop);
                 return hst.getNode(path);

package/dist/src/stores/operation-log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operation-log.d.ts","sourceRoot":"","sources":["../../../src/stores/operation-log.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AACpC,OAAO,KAAK,EAEX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,MAAM,wBAAwB,CAAA;AA4E/B;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0DJ,OAAO,CAAC,kBAAkB,CAAC;8BAkBtB,iBAAiB,WAAU,eAAe;;gCA0DxC,MAAM,KAAG,MAAM,GAAG,IAAI;;kBA2EpC,OAAO,KAAG,OAAO;kBAmDjB,OAAO,KAAG,OAAO;;gCA2FH,MAAM,aAAa,MAAM,KAAG,YAAY,EAAE;uBA1BrD,oBAAoB;oCAmCL,MAAM,UAAU,MAAM;yBAmBnD,MAAM,cACH,MAAM,cACN,MAAM,EAAE,WACZ,SAAS,GAAG,SAAS,GAAG,SAAS,UACjC,MAAM,KACZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAtUmB,OAAO,CAAC,kBAAkB,CAAC;8BAkBtB,iBAAiB,WAAU,eAAe;;gCA0DxC,MAAM,KAAG,MAAM,GAAG,IAAI;;kBA2EpC,OAAO,KAAG,OAAO;kBAmDjB,OAAO,KAAG,OAAO;;gCA2FH,MAAM,aAAa,MAAM,KAAG,YAAY,EAAE;uBA1BrD,oBAAoB;oCAmCL,MAAM,UAAU,MAAM;yBAmBnD,MAAM,cACH,MAAM,cACN,MAAM,EAAE,WACZ,SAAS,GAAG,SAAS,GAAG,SAAS,UACjC,MAAM,KACZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAtUmB,OAAO,CAAC,kBAAkB,CAAC;8BAkBtB,iBAAiB,WAAU,eAAe;;gCA0DxC,MAAM,KAAG,MAAM,GAAG,IAAI;;kBA2EpC,OAAO,KAAG,OAAO;kBAmDjB,OAAO,KAAG,OAAO;;gCA2FH,MAAM,aAAa,MAAM,KAAG,YAAY,EAAE;uBA1BrD,oBAAoB;oCAmCL,MAAM,UAAU,MAAM;yBAmBnD,MAAM,cACH,MAAM,cACN,MAAM,EAAE,WACZ,SAAS,GAAG,SAAS,GAAG,SAAS,UACjC,MAAM,KACZ,MAAM;oLA0MR,CAAA"}
+{"version":3,"file":"operation-log.d.ts","sourceRoot":"","sources":["../../../src/stores/operation-log.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AACpC,OAAO,KAAK,EAEX,YAAY,EACZ,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,aAAa,EACb,MAAM,wBAAwB,CAAA;AA4E/B;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA4DJ,OAAO,CAAC,kBAAkB,CAAC;8BAkBtB,iBAAiB,WAAU,eAAe;;gCA0DxC,MAAM,KAAG,MAAM,GAAG,IAAI;;kBA2EpC,OAAO,KAAG,OAAO;kBAmDjB,OAAO,KAAG,OAAO;;gCA2FH,MAAM,aAAa,MAAM,KAAG,YAAY,EAAE;uBA1BrD,oBAAoB;oCAmCL,MAAM,UAAU,MAAM;yBAmBnD,MAAM,cACH,MAAM,cACN,MAAM,EAAE,WACZ,SAAS,GAAG,SAAS,GAAG,SAAS,UACjC,MAAM,KACZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAtUmB,OAAO,CAAC,kBAAkB,CAAC;8BAkBtB,iBAAiB,WAAU,eAAe;;gCA0DxC,MAAM,KAAG,MAAM,GAAG,IAAI;;kBA2EpC,OAAO,KAAG,OAAO;kBAmDjB,OAAO,KAAG,OAAO;;gCA2FH,MAAM,aAAa,MAAM,KAAG,YAAY,EAAE;uBA1BrD,oBAAoB;oCAmCL,MAAM,UAAU,MAAM;yBAmBnD,MAAM,cACH,MAAM,cACN,MAAM,EAAE,WACZ,SAAS,GAAG,SAAS,GAAG,SAAS,UACjC,MAAM,KACZ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAtUmB,OAAO,CAAC,kBAAkB,CAAC;8BAkBtB,iBAAiB,WAAU,eAAe;;gCA0DxC,MAAM,KAAG,MAAM,GAAG,IAAI;;kBA2EpC,OAAO,KAAG,OAAO;kBAmDjB,OAAO,KAAG,OAAO;;gCA2FH,MAAM,aAAa,MAAM,KAAG,YAAY,EAAE;uBA1BrD,oBAAoB;oCAmCL,MAAM,UAAU,MAAM;yBAmBnD,MAAM,cACH,MAAM,cACN,MAAM,EAAE,WACZ,SAAS,GAAG,SAAS,GAAG,SAAS,UACjC,MAAM,KACZ,MAAM;oLA0MR,CAAA"}

package/dist/{stores → src/stores}/operation-log.js

@@ -436,7 +436,7 @@ export const useOperationLogStore = defineStore('hst-operation-log', () => {
             }
             else if (message.type === 'operation' && message.operations) {
                 // Add batch operations from another tab
-                operations.value.push(...message.operations.map(op => ({ ...op, source: 'sync' })));
+                operations.value.push(...message.operations.map((op) => ({ ...op, source: 'sync' })));
                 currentIndex.value = operations.value.length - 1;
             }
         });