@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/stores/workflowStore.svelte.js

@@ -1,23 +1,26 @@
 /**
  * Workflow Store for FlowDrop (Svelte 5 Runes)
  *
- * Provides global state management for workflows with dirty state tracking
- * and undo/redo history integration.
+ * Provides per-instance state management for workflows with dirty state
+ * tracking and undo/redo history integration.
  *
- * **Important: Single-instance only.** This store uses module-level singletons.
- * Only one FlowDrop editor instance per page is supported. Mounting multiple
- * FlowDrop editors on the same page will cause them to share workflow state.
+ * The reactive state lives in the {@link WorkflowStore} class — one per
+ * FlowDrop instance, created by `createFlowDropInstance()` and resolved in
+ * components via `getInstance().workflow`.
  *
  * @module stores/workflowStore
  */
 import { DEFAULT_WORKFLOW_FORMAT } from '../types/index.js';
-import { historyService } from '../services/historyService.js';
+import { WORKFLOW_SCHEMA_VERSION } from '../schemas/index.js';
 /**
  * Safely build updated workflow metadata, providing defaults for required fields.
+ *
+ * Accepts loosely-typed legacy metadata so it can absorb 1.x documents (where
+ * the schema-version field was named `version`) during load-time healing.
  */
 function buildMetadata(existing, updates) {
     return {
-        version: existing?.version ?? '1.0',
+        schemaVersion: existing?.schemaVersion ?? existing?.version ?? WORKFLOW_SCHEMA_VERSION,
         createdAt: existing?.createdAt ?? new Date().toISOString(),
         updatedAt: new Date().toISOString(),
         author: existing?.author,
@@ -28,336 +31,30 @@ function buildMetadata(existing, updates) {
         ...updates
     };
 }
-// =========================================================================
-// Core Workflow State (Svelte 5 Runes)
-// =========================================================================
-/** Global workflow state */
-let workflowState = $state(null);
-// =========================================================================
-// Dirty State Tracking (Version Counter)
-// =========================================================================
-/**
- * Monotonic edit version — bumps on every mutation action.
- *
- * Used for two purposes:
- * 1. O(1) dirty detection: isDirty = _editVersion !== _savedVersion
- * 2. Save verification protocol: include the version in the save request,
- *    backend echoes it back. If the echoed version doesn't match, the save
- *    didn't persist the version the client submitted.
- */
-let _editVersion = $state(0);
-/**
- * Edit version captured at the last successful save.
- * When _editVersion === _savedVersion, the workflow is clean.
- */
-let _savedVersion = $state(0);
-/**
- * Callback for dirty state changes
- *
- * Set by the App component to notify parent application.
- */
-let onDirtyStateChangeCallback = null;
-/**
- * Callback for workflow changes
- *
- * Set by the App component to notify parent application.
- */
-let onWorkflowChangeCallback = null;
-/**
- * Flag to track if we're currently restoring from history (undo/redo)
- *
- * When true, prevents pushing to history to avoid recursive loops.
- */
-let isRestoringFromHistory = false;
-/**
- * Flag to track if history recording is enabled
- *
- * Can be disabled for bulk operations or when history is not needed.
- */
-let historyEnabled = true;
-// =========================================================================
-// Getter Functions (Reactive State Access)
-// =========================================================================
-/**
- * Get the current workflow store value reactively
- *
- * @returns The current workflow or null
- */
-export function getWorkflowStore() {
-    return workflowState;
-}
-/**
- * Get the current dirty state reactively
- *
- * Reads both _editVersion and _savedVersion, so Svelte tracks them
- * as reactive dependencies — any component using this will re-render
- * when dirty state changes.
- *
- * @returns true if there are unsaved changes
- */
-export function getIsDirty() {
-    return _editVersion !== _savedVersion;
-}
-/**
- * Get the workflow ID reactively
- *
- * @returns The workflow ID or null
- */
-export function getWorkflowId() {
-    return workflowState?.id ?? null;
-}
-/**
- * Get the workflow name reactively
- *
- * @returns The workflow name or 'Untitled Workflow'
- */
-export function getWorkflowName() {
-    return workflowState?.name ?? 'Untitled Workflow';
-}
-/**
- * Get the workflow nodes reactively
- *
- * @returns Array of workflow nodes
- */
-export function getWorkflowNodes() {
-    return workflowState?.nodes ?? [];
-}
-/**
- * Get the workflow edges reactively
- *
- * @returns Array of workflow edges
- */
-export function getWorkflowEdges() {
-    return workflowState?.edges ?? [];
-}
-/**
- * Get the workflow metadata reactively
- *
- * @returns The workflow metadata with defaults
- */
-export function getWorkflowMetadata() {
-    return (workflowState?.metadata ?? {
-        version: '1.0.0',
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        versionId: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        updateNumber: 0
-    });
-}
-/**
- * Get the current workflow format reactively
- *
- * @returns The workflow format string
- */
-export function getWorkflowFormat() {
-    return workflowState?.metadata?.format ?? DEFAULT_WORKFLOW_FORMAT;
-}
-/**
- * Get workflow change summary reactively (useful for triggering saves)
- *
- * @returns Object with nodes, edges, and name
- */
-export function getWorkflowChanged() {
-    return {
-        nodes: getWorkflowNodes(),
-        edges: getWorkflowEdges(),
-        name: getWorkflowName()
-    };
-}
-/**
- * Get workflow validation state reactively
- *
- * @returns Validation info object
- */
-export function getWorkflowValidation() {
-    const nodes = getWorkflowNodes();
-    const edges = getWorkflowEdges();
-    return {
-        hasNodes: nodes.length > 0,
-        hasEdges: edges.length > 0,
-        nodeCount: nodes.length,
-        edgeCount: edges.length,
-        isValid: nodes.length > 0 && edges.length >= 0
-    };
-}
-/**
- * Get workflow metadata change summary reactively
- *
- * @returns Metadata change info
- */
-export function getWorkflowMetadataChanged() {
-    const metadata = getWorkflowMetadata();
-    return {
-        createdAt: metadata.createdAt,
-        updatedAt: metadata.updatedAt,
-        version: metadata.version ?? '1.0.0'
-    };
-}
-/**
- * Get connected handles reactively
- *
- * Provides a Set of all handle IDs that are currently connected to edges.
- * Used by node components to implement hideUnconnectedHandles functionality.
- *
- * @example
- * ```typescript
- * import { getConnectedHandles } from './workflowStore.svelte.js';
- *
- * // Check if a specific handle is connected
- * const isConnected = getConnectedHandles().has('node-1-input-data');
- * ```
- */
-export function getConnectedHandles() {
-    const edges = getWorkflowEdges();
-    const handles = new Set();
-    edges.forEach((edge) => {
-        // Add source handle (output port)
-        if (edge.sourceHandle) {
-            handles.add(edge.sourceHandle);
-        }
-        // Add target handle (input port)
-        if (edge.targetHandle) {
-            handles.add(edge.targetHandle);
-        }
-    });
-    return handles;
-}
-// =========================================================================
-// Callback Setters
-// =========================================================================
-/**
- * Set the dirty state change callback
- *
- * @param callback - Function to call when dirty state changes
- */
-export function setOnDirtyStateChange(callback) {
-    onDirtyStateChangeCallback = callback;
-}
-/**
- * Set the workflow change callback
- *
- * @param callback - Function to call when workflow changes
- */
-export function setOnWorkflowChange(callback) {
-    onWorkflowChangeCallback = callback;
-}
-// =========================================================================
-// Internal Helpers
-// =========================================================================
-/**
- * Bump the edit version and notify dirty state change if needed.
- * Called by every mutation action.
- */
-function bumpVersion() {
-    _editVersion++;
-    // Dirty state just flipped from clean → dirty
-    if (_editVersion - 1 === _savedVersion) {
-        if (onDirtyStateChangeCallback) {
-            onDirtyStateChangeCallback(true);
-        }
-    }
-}
-/**
- * Notify external listeners of a workflow change.
- * Does NOT bump the version — callers that mutate must call bumpVersion() explicitly.
- *
- * @param changeType - The type of change that occurred
- */
-function notifyWorkflowChange(changeType) {
-    if (workflowState && onWorkflowChangeCallback) {
-        onWorkflowChangeCallback(workflowState, changeType);
-    }
-}
-/**
- * Mark the current workflow state as saved.
- *
- * Captures the current edit version so isDirty becomes false.
- * Call this after a successful backend save.
- */
-export function markAsSaved() {
-    const wasDirty = _editVersion !== _savedVersion;
-    _savedVersion = _editVersion;
-    if (wasDirty && onDirtyStateChangeCallback) {
-        onDirtyStateChangeCallback(false);
-    }
-}
-/**
- * Check if there are unsaved changes (non-reactive version for plain TS)
- *
- * @returns true if there are unsaved changes
- */
-export function isDirty() {
-    return _editVersion !== _savedVersion;
-}
-/**
- * Get the current edit version.
- *
- * Use this for the save verification protocol:
- * 1. Before save: `const v = getEditVersion()`
- * 2. Include `v` in the save request payload
- * 3. Backend echoes `v` in the response
- * 4. If echoed version matches: `markAsSaved()`
- * 5. If not: the save didn't persist the version you submitted — reset from backend response
- *
- * @returns The current monotonic edit version
- */
-export function getEditVersion() {
-    return _editVersion;
-}
 /**
- * Enable or disable history recording
+ * Normalize workflow metadata at load time (the only back-compat path we keep,
+ * mirroring the storage-key migration in commit 8fab9157).
  *
- * Useful for bulk operations where you don't want individual history entries.
+ * Rules:
+ * - missing `metadata` → `buildMetadata(undefined)` (fresh required defaults)
+ * - legacy `version` key present → copied to `schemaVersion` when absent, then
+ *   the legacy key is dropped
  *
- * @param enabled - Whether history should be recorded
+ * Idempotent: re-running on an already-healed workflow returns equivalent
+ * metadata (round-trip stable).
  */
-export function setHistoryEnabled(enabled) {
-    historyEnabled = enabled;
-}
-/**
- * Check if history recording is enabled
- *
- * @returns true if history is being recorded
- */
-export function isHistoryEnabled() {
-    return historyEnabled;
-}
-/**
- * Set the restoring from history flag
- *
- * Used internally by the history store when performing undo/redo.
- *
- * @param restoring - Whether we're currently restoring from history
- */
-export function setRestoringFromHistory(restoring) {
-    isRestoringFromHistory = restoring;
-}
-/**
- * Push current state to history before making changes
- *
- * @param description - Description of the change about to be made
- * @param workflow - Optional workflow to push (uses store if not provided)
- */
-function pushToHistory(description, workflow) {
-    if (!historyEnabled || isRestoringFromHistory) {
-        return;
-    }
-    const workflowToPush = workflow ?? workflowState;
-    if (workflowToPush) {
-        historyService.push(workflowToPush, { description });
+export function normalizeWorkflowMetadata(workflow) {
+    const raw = workflow.metadata;
+    if (!raw) {
+        return { ...workflow, metadata: buildMetadata(undefined) };
     }
+    const { version: legacyVersion, ...rest } = raw;
+    const healed = {
+        ...rest,
+        schemaVersion: rest.schemaVersion ?? legacyVersion ?? WORKFLOW_SCHEMA_VERSION
+    };
+    return { ...workflow, metadata: healed };
 }
-/**
- * Get the current workflow (non-reactive version for plain TS)
- *
- * @returns The current workflow or null
- */
-export function getWorkflow() {
-    return workflowState;
-}
-// =========================================================================
-// Helper Functions
-// =========================================================================
 /**
  * Check if workflow data has actually changed
  *
@@ -397,235 +94,486 @@ function hasWorkflowDataChanged(currentWorkflow, newNodes, newEdges) {
     }
     return false;
 }
+/**
+ * Heal nodes that are missing `data.nodeId`.
+ *
+ * Node components derive their handle IDs from `data.nodeId` — a node without
+ * it renders with zero handles and SvelteFlow silently drops every edge
+ * anchored to it, making an intact graph look corrupted on the canvas.
+ * `data.nodeId` always equals the node's own `id`, so it is safe to restore.
+ */
+function healMissingNodeIds(workflow) {
+    if (!workflow.nodes?.some((node) => !node.data.nodeId)) {
+        return workflow;
+    }
+    return {
+        ...workflow,
+        nodes: workflow.nodes.map((node) => node.data.nodeId ? node : { ...node, data: { ...node.data, nodeId: node.id } })
+    };
+}
 // =========================================================================
-// Workflow Actions
+// WorkflowStore (per-instance reactive state)
 // =========================================================================
 /**
- * Actions for updating the workflow
+ * Per-instance workflow state with dirty tracking and history integration.
  *
- * All actions that modify the workflow will trigger dirty state updates
- * and emit change events.
+ * All reads go through getters backed by `$state`, so reading them inside a
+ * component template or `$derived` tracks reactively, exactly like the
+ * legacy module-level functions did.
  */
-export const workflowActions = {
+export class WorkflowStore {
+    /** Current workflow */
+    #workflow = $state(null);
+    /**
+     * Monotonic edit version — bumps on every mutation action.
+     *
+     * Used for two purposes:
+     * 1. O(1) dirty detection: isDirty = #editVersion !== #savedVersion
+     * 2. Save verification protocol: include the version in the save request,
+     *    backend echoes it back. If the echoed version doesn't match, the save
+     *    didn't persist the version the client submitted.
+     */
+    #editVersion = $state(0);
+    /**
+     * Edit version captured at the last successful save.
+     * When #editVersion === #savedVersion, the workflow is clean.
+     */
+    #savedVersion = $state(0);
+    /** Callback for dirty state changes — set by the App component. */
+    #onDirtyStateChange = null;
+    /** Callback for workflow changes — set by the App component. */
+    #onWorkflowChange = null;
+    /**
+     * Whether we're currently restoring from history (undo/redo).
+     * When true, prevents pushing to history to avoid recursive loops.
+     */
+    #restoringFromHistory = false;
+    /** Whether history recording is enabled (disable for bulk operations). */
+    #historyEnabled = true;
+    /** Undo/redo engine for this instance (constructor-injected). */
+    #history;
+    /** Bound mutation facade — see {@link WorkflowStoreActions}. */
+    actions;
+    constructor(history) {
+        this.#history = history;
+        this.actions = Object.freeze({
+            initialize: this.initialize.bind(this),
+            updateWorkflow: this.updateWorkflow.bind(this),
+            restoreFromHistory: this.restoreFromHistory.bind(this),
+            updateNodes: this.updateNodes.bind(this),
+            updateEdges: this.updateEdges.bind(this),
+            updateName: this.updateName.bind(this),
+            addNode: this.addNode.bind(this),
+            removeNode: this.removeNode.bind(this),
+            addEdge: this.addEdge.bind(this),
+            removeEdge: this.removeEdge.bind(this),
+            updateNode: this.updateNode.bind(this),
+            clear: this.clear.bind(this),
+            updateMetadata: this.updateMetadata.bind(this),
+            batchUpdate: this.batchUpdate.bind(this),
+            swapNode: this.swapNode.bind(this),
+            pushHistory: this.pushHistory.bind(this)
+        });
+    }
+    // -----------------------------------------------------------------------
+    // Reactive getters
+    // -----------------------------------------------------------------------
+    /** The current workflow, or null when none is loaded. */
+    get current() {
+        return this.#workflow;
+    }
+    /**
+     * Whether there are unsaved changes.
+     *
+     * Reads both #editVersion and #savedVersion, so Svelte tracks them as
+     * reactive dependencies — any component using this re-renders when dirty
+     * state changes.
+     */
+    get isDirty() {
+        return this.#editVersion !== this.#savedVersion;
+    }
+    /** The workflow ID, or null. */
+    get id() {
+        return this.#workflow?.id ?? null;
+    }
+    /** The workflow name, or 'Untitled Workflow'. */
+    get name() {
+        return this.#workflow?.name ?? 'Untitled Workflow';
+    }
+    /** The workflow nodes. */
+    get nodes() {
+        return this.#workflow?.nodes ?? [];
+    }
+    /** The workflow edges. */
+    get edges() {
+        return this.#workflow?.edges ?? [];
+    }
+    /** The workflow metadata, with defaults. */
+    get metadata() {
+        return (this.#workflow?.metadata ?? {
+            schemaVersion: WORKFLOW_SCHEMA_VERSION,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            versionId: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            updateNumber: 0
+        });
+    }
+    /** The workflow format string. */
+    get format() {
+        return this.#workflow?.metadata?.format ?? DEFAULT_WORKFLOW_FORMAT;
+    }
+    /** Workflow change summary (useful for triggering saves). */
+    get changeSummary() {
+        return {
+            nodes: this.nodes,
+            edges: this.edges,
+            name: this.name
+        };
+    }
+    /** Workflow validation state. */
+    get validation() {
+        const nodes = this.nodes;
+        const edges = this.edges;
+        return {
+            hasNodes: nodes.length > 0,
+            hasEdges: edges.length > 0,
+            nodeCount: nodes.length,
+            edgeCount: edges.length,
+            isValid: nodes.length > 0 && edges.length >= 0
+        };
+    }
+    /** Workflow metadata change summary. */
+    get metadataChangeSummary() {
+        const metadata = this.metadata;
+        return {
+            createdAt: metadata.createdAt,
+            updatedAt: metadata.updatedAt,
+            schemaVersion: metadata.schemaVersion ?? WORKFLOW_SCHEMA_VERSION
+        };
+    }
+    /**
+     * Set of all handle IDs currently connected to edges.
+     *
+     * Used by node components to implement hideUnconnectedHandles.
+     */
+    get connectedHandles() {
+        const handles = new Set();
+        this.edges.forEach((edge) => {
+            // Add source handle (output port)
+            if (edge.sourceHandle) {
+                handles.add(edge.sourceHandle);
+            }
+            // Add target handle (input port)
+            if (edge.targetHandle) {
+                handles.add(edge.targetHandle);
+            }
+        });
+        return handles;
+    }
+    /**
+     * The current monotonic edit version.
+     *
+     * Use this for the save verification protocol:
+     * 1. Before save: `const v = store.editVersion`
+     * 2. Include `v` in the save request payload
+     * 3. Backend echoes `v` in the response
+     * 4. If echoed version matches: `store.markAsSaved()`
+     * 5. If not: the save didn't persist the version you submitted — reset from backend response
+     */
+    get editVersion() {
+        return this.#editVersion;
+    }
+    /** Whether history recording is enabled. */
+    get historyEnabled() {
+        return this.#historyEnabled;
+    }
+    /** Enable or disable history recording (e.g. for bulk operations). */
+    set historyEnabled(enabled) {
+        this.#historyEnabled = enabled;
+    }
+    // -----------------------------------------------------------------------
+    // Callback setters & save protocol
+    // -----------------------------------------------------------------------
+    /** Set the dirty state change callback. */
+    setOnDirtyStateChange(callback) {
+        this.#onDirtyStateChange = callback;
+    }
+    /** Set the workflow change callback. */
+    setOnWorkflowChange(callback) {
+        this.#onWorkflowChange = callback;
+    }
+    /**
+     * Mark the current workflow state as saved.
+     *
+     * Captures the current edit version so isDirty becomes false.
+     * Call this after a successful backend save.
+     */
+    markAsSaved() {
+        const wasDirty = this.#editVersion !== this.#savedVersion;
+        this.#savedVersion = this.#editVersion;
+        if (wasDirty && this.#onDirtyStateChange) {
+            this.#onDirtyStateChange(false);
+        }
+    }
+    /**
+     * Set the restoring from history flag.
+     *
+     * Used internally by the history store when performing undo/redo.
+     */
+    setRestoringFromHistory(restoring) {
+        this.#restoringFromHistory = restoring;
+    }
+    // -----------------------------------------------------------------------
+    // Internal helpers
+    // -----------------------------------------------------------------------
+    /**
+     * Bump the edit version and notify dirty state change if needed.
+     * Called by every mutation action.
+     */
+    #bumpVersion() {
+        this.#editVersion++;
+        // Dirty state just flipped from clean → dirty
+        if (this.#editVersion - 1 === this.#savedVersion) {
+            if (this.#onDirtyStateChange) {
+                this.#onDirtyStateChange(true);
+            }
+        }
+    }
+    /**
+     * Notify external listeners of a workflow change.
+     * Does NOT bump the version — callers that mutate must call #bumpVersion() explicitly.
+     */
+    #notifyWorkflowChange(changeType) {
+        if (this.#workflow && this.#onWorkflowChange) {
+            this.#onWorkflowChange(this.#workflow, changeType);
+        }
+    }
+    /**
+     * Push current state to history before making changes.
+     *
+     * @param description - Description of the change about to be made
+     * @param workflow - Optional workflow to push (uses store state if not provided)
+     */
+    #pushToHistory(description, workflow) {
+        if (!this.#historyEnabled || this.#restoringFromHistory) {
+            return;
+        }
+        const workflowToPush = workflow ?? this.#workflow;
+        if (workflowToPush) {
+            this.#history.push(workflowToPush, { description });
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Mutation actions
+    // -----------------------------------------------------------------------
     /**
-     * Initialize workflow (from load or new)
+     * Initialize workflow (from load or new).
      *
      * This sets the initial saved snapshot, clears dirty state, and initializes history.
      */
-    initialize: (workflow) => {
-        workflowState = workflow;
+    initialize(workflow) {
+        workflow = normalizeWorkflowMetadata(workflow);
+        workflow = healMissingNodeIds(workflow);
+        this.#workflow = workflow;
         // Reset version counters — workflow is "clean" after initialization
-        _editVersion = 0;
-        _savedVersion = 0;
-        if (onDirtyStateChangeCallback) {
-            onDirtyStateChangeCallback(false);
+        this.#editVersion = 0;
+        this.#savedVersion = 0;
+        if (this.#onDirtyStateChange) {
+            this.#onDirtyStateChange(false);
         }
         // Initialize history with the loaded workflow
-        historyService.initialize(workflow);
-    },
+        this.#history.initialize(workflow);
+    }
     /**
-     * Update the entire workflow
+     * Update the entire workflow.
      *
      * Note: This is typically called from SvelteFlow sync and should not push to history
      * for every small change. History is pushed by specific actions or drag handlers.
      */
-    updateWorkflow: (workflow) => {
-        workflowState = workflow;
-        bumpVersion();
-        notifyWorkflowChange('metadata');
-    },
+    updateWorkflow(workflow) {
+        this.#workflow = workflow;
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('metadata');
+    }
     /**
-     * Restore workflow from history (undo/redo)
+     * Restore workflow from history (undo/redo).
      *
      * This bypasses history recording to prevent recursive loops.
      */
-    restoreFromHistory: (workflow) => {
-        isRestoringFromHistory = true;
-        workflowState = workflow;
-        bumpVersion();
-        notifyWorkflowChange('metadata');
-        isRestoringFromHistory = false;
-    },
-    /**
-     * Update nodes
-     */
-    updateNodes: (nodes) => {
-        if (!workflowState)
+    restoreFromHistory(workflow) {
+        this.#restoringFromHistory = true;
+        workflow = normalizeWorkflowMetadata(workflow);
+        this.#workflow = workflow;
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('metadata');
+        this.#restoringFromHistory = false;
+    }
+    /** Update nodes. */
+    updateNodes(nodes) {
+        if (!this.#workflow)
             return;
         // Check if nodes have actually changed to prevent infinite loops
-        if (!hasWorkflowDataChanged(workflowState, nodes, workflowState.edges)) {
+        if (!hasWorkflowDataChanged(this.#workflow, nodes, this.#workflow.edges)) {
             return;
         }
         // Generate unique version identifier
         const versionId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        workflowState = {
-            ...workflowState,
+        this.#workflow = {
+            ...this.#workflow,
             nodes,
-            metadata: buildMetadata(workflowState.metadata, {
+            metadata: buildMetadata(this.#workflow.metadata, {
                 versionId,
-                updateNumber: (workflowState.metadata?.updateNumber ?? 0) + 1
+                updateNumber: (this.#workflow.metadata?.updateNumber ?? 0) + 1
             })
         };
-        bumpVersion();
-        notifyWorkflowChange('node_move');
-    },
-    /**
-     * Update edges
-     */
-    updateEdges: (edges) => {
-        if (!workflowState)
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('node_move');
+    }
+    /** Update edges. */
+    updateEdges(edges) {
+        if (!this.#workflow)
             return;
         // Check if edges have actually changed to prevent infinite loops
-        if (!hasWorkflowDataChanged(workflowState, workflowState.nodes, edges)) {
+        if (!hasWorkflowDataChanged(this.#workflow, this.#workflow.nodes, edges)) {
             return;
         }
         // Generate unique version identifier
         const versionId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        workflowState = {
-            ...workflowState,
+        this.#workflow = {
+            ...this.#workflow,
             edges,
-            metadata: buildMetadata(workflowState.metadata, {
+            metadata: buildMetadata(this.#workflow.metadata, {
                 versionId,
-                updateNumber: (workflowState.metadata?.updateNumber ?? 0) + 1
+                updateNumber: (this.#workflow.metadata?.updateNumber ?? 0) + 1
             })
         };
-        bumpVersion();
-        notifyWorkflowChange('edge_add');
-    },
-    /**
-     * Update workflow name
-     */
-    updateName: (name) => {
-        if (!workflowState)
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('edge_add');
+    }
+    /** Update workflow name. */
+    updateName(name) {
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
+        this.#workflow = {
+            ...this.#workflow,
             name,
-            metadata: buildMetadata(workflowState.metadata)
+            metadata: buildMetadata(this.#workflow.metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('name');
-    },
-    /**
-     * Add a node
-     */
-    addNode: (node) => {
-        pushToHistory('Add node');
-        if (!workflowState)
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('name');
+    }
+    /** Add a node. */
+    addNode(node) {
+        this.#pushToHistory('Add node');
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
-            nodes: [...workflowState.nodes, node],
-            metadata: buildMetadata(workflowState.metadata)
+        this.#workflow = {
+            ...this.#workflow,
+            nodes: [...this.#workflow.nodes, node],
+            metadata: buildMetadata(this.#workflow.metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('node_add');
-    },
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('node_add');
+    }
     /**
-     * Remove a node
+     * Remove a node.
      *
      * This is an atomic operation that also removes connected edges.
      * A single undo will restore both the node and its edges.
      */
-    removeNode: (nodeId) => {
-        pushToHistory('Delete node');
-        if (!workflowState)
+    removeNode(nodeId) {
+        this.#pushToHistory('Delete node');
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
-            nodes: workflowState.nodes.filter((node) => node.id !== nodeId),
-            edges: workflowState.edges.filter((edge) => edge.source !== nodeId && edge.target !== nodeId),
-            metadata: buildMetadata(workflowState.metadata)
+        this.#workflow = {
+            ...this.#workflow,
+            nodes: this.#workflow.nodes.filter((node) => node.id !== nodeId),
+            edges: this.#workflow.edges.filter((edge) => edge.source !== nodeId && edge.target !== nodeId),
+            metadata: buildMetadata(this.#workflow.metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('node_remove');
-    },
-    /**
-     * Add an edge
-     */
-    addEdge: (edge) => {
-        pushToHistory('Add connection');
-        if (!workflowState)
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('node_remove');
+    }
+    /** Add an edge. */
+    addEdge(edge) {
+        this.#pushToHistory('Add connection');
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
-            edges: [...workflowState.edges, edge],
-            metadata: buildMetadata(workflowState.metadata)
+        this.#workflow = {
+            ...this.#workflow,
+            edges: [...this.#workflow.edges, edge],
+            metadata: buildMetadata(this.#workflow.metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('edge_add');
-    },
-    /**
-     * Remove an edge
-     */
-    removeEdge: (edgeId) => {
-        pushToHistory('Delete connection');
-        if (!workflowState)
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('edge_add');
+    }
+    /** Remove an edge. */
+    removeEdge(edgeId) {
+        this.#pushToHistory('Delete connection');
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
-            edges: workflowState.edges.filter((edge) => edge.id !== edgeId),
-            metadata: buildMetadata(workflowState.metadata)
+        this.#workflow = {
+            ...this.#workflow,
+            edges: this.#workflow.edges.filter((edge) => edge.id !== edgeId),
+            metadata: buildMetadata(this.#workflow.metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('edge_remove');
-    },
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('edge_remove');
+    }
     /**
-     * Update a specific node
+     * Update a specific node.
      *
      * Used for config changes. Pushes to history for undo support.
      */
-    updateNode: (nodeId, updates) => {
-        pushToHistory('Update node config');
-        if (!workflowState)
+    updateNode(nodeId, updates) {
+        this.#pushToHistory('Update node config');
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
-            nodes: workflowState.nodes.map((node) => node.id === nodeId ? { ...node, ...updates } : node),
-            metadata: buildMetadata(workflowState.metadata)
+        this.#workflow = {
+            ...this.#workflow,
+            nodes: this.#workflow.nodes.map((node) => node.id === nodeId ? { ...node, ...updates } : node),
+            metadata: buildMetadata(this.#workflow.metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('node_config');
-    },
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('node_config');
+    }
     /**
-     * Clear the workflow
+     * Clear the workflow.
      *
      * Resets the workflow and clears history.
      */
-    clear: () => {
-        workflowState = null;
-        _editVersion = 0;
-        _savedVersion = 0;
-        historyService.clear();
-        if (onDirtyStateChangeCallback) {
-            onDirtyStateChangeCallback(false);
+    clear() {
+        this.#workflow = null;
+        this.#editVersion = 0;
+        this.#savedVersion = 0;
+        this.#history.clear();
+        if (this.#onDirtyStateChange) {
+            this.#onDirtyStateChange(false);
         }
-    },
-    /**
-     * Update workflow metadata
-     */
-    updateMetadata: (metadata) => {
-        if (!workflowState)
+    }
+    /** Update workflow metadata. */
+    updateMetadata(metadata) {
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
-            metadata: buildMetadata(workflowState.metadata, metadata)
+        this.#workflow = {
+            ...this.#workflow,
+            metadata: buildMetadata(this.#workflow.metadata, metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('metadata');
-    },
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('metadata');
+    }
     /**
-     * Batch update nodes and edges
+     * Batch update nodes and edges.
      *
      * Useful for complex operations that update multiple things at once.
      * Creates a single history entry for the entire batch.
      */
-    batchUpdate: (updates) => {
-        pushToHistory('Batch update');
-        if (!workflowState)
+    batchUpdate(updates) {
+        this.#pushToHistory('Batch update');
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
+        this.#workflow = {
+            ...this.#workflow,
             ...(updates.nodes && { nodes: updates.nodes }),
             ...(updates.edges && { edges: updates.edges }),
             ...(updates.name && { name: updates.name }),
@@ -633,32 +581,32 @@ export const workflowActions = {
                 description: updates.description
             }),
             ...(updates.config !== undefined && { config: updates.config }),
-            metadata: buildMetadata(workflowState.metadata, updates.metadata ?? undefined)
+            metadata: buildMetadata(this.#workflow.metadata, updates.metadata ?? undefined)
         };
-        bumpVersion();
-        notifyWorkflowChange('metadata');
-    },
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('metadata');
+    }
     /**
      * Swap a node — atomically replaces nodes and edges with a descriptive history entry.
      *
      * Unlike batchUpdate, this uses `"node_swap"` as the change type and
      * records a meaningful description for the undo history.
      */
-    swapNode: (updates) => {
-        pushToHistory(updates.description ?? 'Swap node');
-        if (!workflowState)
+    swapNode(updates) {
+        this.#pushToHistory(updates.description ?? 'Swap node');
+        if (!this.#workflow)
             return;
-        workflowState = {
-            ...workflowState,
+        this.#workflow = {
+            ...this.#workflow,
             nodes: updates.nodes,
             edges: updates.edges,
-            metadata: buildMetadata(workflowState.metadata)
+            metadata: buildMetadata(this.#workflow.metadata)
         };
-        bumpVersion();
-        notifyWorkflowChange('node_swap');
-    },
+        this.#bumpVersion();
+        this.#notifyWorkflowChange('node_swap');
+    }
     /**
-     * Push current state to history manually
+     * Push current state to history manually.
      *
      * Use this before operations that modify the workflow through other means
      * (e.g., drag operations handled by SvelteFlow directly).
@@ -666,7 +614,7 @@ export const workflowActions = {
      * @param description - Description of the upcoming change
      * @param workflow - Optional workflow to push (uses store state if not provided)
      */
-    pushHistory: (description, workflow) => {
-        pushToHistory(description, workflow);
+    pushHistory(description, workflow) {
+        this.#pushToHistory(description, workflow);
     }
-};
+}