@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/services/globalSave.js

@@ -8,8 +8,7 @@
  * construction happen in exactly one place.
  */
 import { tick } from 'svelte';
-import { getWorkflowStore, workflowActions, markAsSaved as storeMarkAsSaved } from '../stores/workflowStore.svelte.js';
-import { workflowApi, setEndpointConfig } from './api.js';
+import { getDefaultInstance } from '../stores/instanceContainer.svelte.js';
 import { createEndpointConfig } from '../config/endpoints.js';
 import { v4 as uuidv4 } from 'uuid';
 import { DEFAULT_WORKFLOW_FORMAT } from '../types/index.js';
@@ -19,29 +18,19 @@ import { DEFAULT_FEATURES } from '../types/events.js';
 // Internal helpers
 // ---------------------------------------------------------------------------
 /**
- * Ensure API configuration is initialized.
- * This is needed when the global save function is called from the layout component
- * which doesn't initialize the API configuration like the App component does.
+ * Ensure the instance's API context is configured.
+ * This is needed when the global save function is called from the layout
+ * component which doesn't initialize the API configuration like <App> does.
  */
-async function ensureApiConfiguration() {
-    try {
-        const { getEndpointConfig } = await import('./api.js');
-        const currentConfig = getEndpointConfig();
-        if (currentConfig && currentConfig.baseUrl) {
-            return;
-        }
-    }
-    catch {
-        // Could not check existing API configuration, initializing
+function ensureApiConfiguration(fd) {
+    if (fd.api.isConfigured() && fd.api.config?.baseUrl) {
+        return;
     }
     // API configuration is not initialized — derive URL from window.location when available
     const apiBaseUrl = typeof window !== 'undefined'
         ? `${window.location.protocol}//${window.location.host}/api/flowdrop`
         : '/api/flowdrop';
     const config = createEndpointConfig(apiBaseUrl, {
-        auth: {
-            type: 'none'
-        },
         timeout: 10000,
         retry: {
             enabled: true,
@@ -50,7 +39,7 @@ async function ensureApiConfiguration() {
             backoff: 'exponential'
         }
     });
-    setEndpointConfig(config);
+    fd.api.configure(config);
 }
 /**
  * Flush any pending form changes by blurring the active element.
@@ -79,18 +68,21 @@ async function flushPendingFormChanges() {
  *  1. Flush pending form changes (blur active element + tick)
  *  2. Optionally call onBeforeSave — return false cancels the save
  *  3. Build the canonical Workflow object (preserving metadata, format, etc.)
- *  4. Persist via enhanced apiClient or legacy workflowApi
+ *  4. Persist via the instance's API client (fd.api.client)
  *  5. Update the store if the server assigned a new ID
  *  6. Call onMarkAsSaved / onAfterSave hooks
  *  7. Show toast notifications (respecting features.showToasts)
  */
 export async function globalSaveWorkflow(options = {}) {
-    const { apiClient, eventHandlers, onMarkAsSaved, onSaved } = options;
+    const { eventHandlers, onMarkAsSaved, onSaved } = options;
     const features = { ...DEFAULT_FEATURES, ...options.features };
+    // Resolve the target instance; defaults to the page-default instance.
+    const fd = options.instance ?? getDefaultInstance();
+    const readWorkflow = () => fd.workflow.current;
     // Step 1 — Flush pending form changes (single location for this logic)
     await flushPendingFormChanges();
-    // Get current workflow from global store after flush
-    const currentWorkflow = getWorkflowStore();
+    // Get current workflow from the instance's store after flush
+    const currentWorkflow = readWorkflow();
     if (!currentWorkflow) {
         if (features.showToasts) {
             apiToasts.error('Save workflow', 'No workflow to save');
@@ -107,7 +99,7 @@ export async function globalSaveWorkflow(options = {}) {
     const loadingToast = features.showToasts ? apiToasts.loading('Saving workflow') : null;
     try {
         // Ensure API configuration is initialised (needed when called outside App.svelte)
-        await ensureApiConfiguration();
+        ensureApiConfiguration(fd);
         // Step 3 — Build the canonical workflow object.
         // Preserve all existing metadata fields (format, tags, etc.) so nothing is dropped.
         //
@@ -124,35 +116,21 @@ export async function globalSaveWorkflow(options = {}) {
             edges: currentWorkflow.edges || [],
             metadata: {
                 ...currentWorkflow.metadata,
-                version: currentWorkflow.metadata?.version || '1.0.0',
+                schemaVersion: currentWorkflow.metadata?.schemaVersion || '1.0.0',
                 format: currentWorkflow.metadata?.format || DEFAULT_WORKFLOW_FORMAT,
                 createdAt: currentWorkflow.metadata?.createdAt || new Date().toISOString(),
                 updatedAt: new Date().toISOString()
             }
         };
-        // Step 4 — Persist
-        let savedWorkflow;
-        if (apiClient) {
-            if (isExistingWorkflow) {
-                savedWorkflow = await apiClient.updateWorkflow(finalWorkflow.id, finalWorkflow);
-            }
-            else {
-                savedWorkflow = await apiClient.saveWorkflow(finalWorkflow);
-            }
-        }
-        else {
-            // Legacy path
-            if (isExistingWorkflow) {
-                savedWorkflow = await workflowApi.updateWorkflow(finalWorkflow.id, finalWorkflow);
-            }
-            else {
-                const { id: _id, ...workflowData } = finalWorkflow;
-                savedWorkflow = await workflowApi.createWorkflow(workflowData);
-            }
-        }
+        // Step 4 — Persist via this instance's API client.
+        // id-presence (computed above) decides update vs create — never UUID-regex.
+        const apiClient = fd.api.client;
+        const savedWorkflow = isExistingWorkflow
+            ? await apiClient.updateWorkflow(finalWorkflow.id, finalWorkflow)
+            : await apiClient.saveWorkflow(finalWorkflow);
         // Step 5 — If the server assigned a new ID, sync the store
         if (savedWorkflow.id && savedWorkflow.id !== finalWorkflow.id) {
-            workflowActions.batchUpdate({
+            fd.workflow.batchUpdate({
                 nodes: finalWorkflow.nodes,
                 edges: finalWorkflow.edges,
                 name: finalWorkflow.name,
@@ -167,8 +145,7 @@ export async function globalSaveWorkflow(options = {}) {
             onMarkAsSaved();
         }
         else {
-            // Fallback: call the store's own markAsSaved if no callback was provided
-            storeMarkAsSaved();
+            fd.workflow.markAsSaved();
         }
         // Notify caller with the definitive saved workflow (server-assigned ID)
         if (onSaved) {
@@ -190,7 +167,7 @@ export async function globalSaveWorkflow(options = {}) {
             dismissToast(loadingToast);
         const errorObj = error instanceof Error ? error : new Error('Unknown error occurred');
         // onSaveError hook
-        const currentWorkflowForError = getWorkflowStore();
+        const currentWorkflowForError = readWorkflow();
         if (eventHandlers?.onSaveError && currentWorkflowForError) {
             await eventHandlers.onSaveError(errorObj, currentWorkflowForError);
         }
@@ -218,7 +195,8 @@ export async function globalExportWorkflow(options = {}) {
     try {
         // Flush pending changes before exporting (same discipline as save)
         await flushPendingFormChanges();
-        const currentWorkflow = getWorkflowStore();
+        const fd = options.instance ?? getDefaultInstance();
+        const currentWorkflow = fd.workflow.current;
         if (!currentWorkflow) {
             if (features.showToasts) {
                 apiToasts.error('Export workflow', 'No workflow to export');
@@ -234,7 +212,7 @@ export async function globalExportWorkflow(options = {}) {
             edges: currentWorkflow.edges || [],
             metadata: {
                 ...currentWorkflow.metadata,
-                version: currentWorkflow.metadata?.version || '1.0.0',
+                schemaVersion: currentWorkflow.metadata?.schemaVersion || '1.0.0',
                 format: currentWorkflow.metadata?.format || DEFAULT_WORKFLOW_FORMAT,
                 createdAt: currentWorkflow.metadata?.createdAt || new Date().toISOString(),
                 updatedAt: new Date().toISOString()

package/dist/services/historyService.d.ts

@@ -202,9 +202,15 @@ export declare class HistoryService {
     private notifyChange;
 }
 /**
- * Singleton instance of the history service
+ * History service of the page-default FlowDrop instance.
  *
- * Use this for the main workflow editor. For isolated instances,
- * create a new HistoryService directly.
+ * Kept as a module-level export for backward compatibility (re-exported via
+ * `@flowdrop/flowdrop/editor`) — `createFlowDropInstance({ isDefault: true })`
+ * adopts this exact object, so legacy `historyService.undo()` calls keep
+ * operating on the default editor's history stack. Holds no reactive state,
+ * so module-level construction is SSR-safe.
+ *
+ * For additional editor instances, the instance container creates a fresh
+ * `new HistoryService()` — use `getInstance().history` in components.
  */
 export declare const historyService: HistoryService;

package/dist/services/historyService.js

@@ -328,9 +328,15 @@ export class HistoryService {
 // Singleton Instance
 // =========================================================================
 /**
- * Singleton instance of the history service
+ * History service of the page-default FlowDrop instance.
  *
- * Use this for the main workflow editor. For isolated instances,
- * create a new HistoryService directly.
+ * Kept as a module-level export for backward compatibility (re-exported via
+ * `@flowdrop/flowdrop/editor`) — `createFlowDropInstance({ isDefault: true })`
+ * adopts this exact object, so legacy `historyService.undo()` calls keep
+ * operating on the default editor's history stack. Holds no reactive state,
+ * so module-level construction is SSR-safe.
+ *
+ * For additional editor instances, the instance container creates a fresh
+ * `new HistoryService()` — use `getInstance().history` in components.
  */
 export const historyService = new HistoryService();

package/dist/services/interruptService.d.ts

@@ -8,6 +8,8 @@
  * @module services/interruptService
  */
 import type { Interrupt, InterruptPollingConfig } from '../types/interrupt.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+import type { AuthProvider } from '../types/auth.js';
 /**
  * Interrupt Service class
  *
@@ -46,19 +48,23 @@ export declare class InterruptService {
     /**
      * Check if interrupt endpoints are configured
      *
+     * @param config - The instance's endpoint configuration (from fd.api.config)
      * @returns True if interrupt endpoints are available
      */
-    isConfigured(): boolean;
+    isConfigured(config: EndpointConfig | null): boolean;
     /**
-     * Get the endpoint configuration
+     * Validate and return the caller-supplied endpoint configuration.
      *
-     * @throws Error if endpoint configuration is not set
+     * Callers thread the config from `getInstance().api.config`.
+     *
+     * @throws Error if endpoint configuration is not set or lacks interrupts
      * @returns The endpoint configuration
      */
     private getConfig;
     /**
      * Generic API request helper
      *
+     * @param config - The endpoint configuration
      * @param url - The URL to fetch
      * @param options - Fetch options
      * @returns The parsed JSON response
@@ -70,7 +76,7 @@ export declare class InterruptService {
      * @param interruptId - The interrupt UUID
      * @returns The interrupt details
      */
-    getInterrupt(interruptId: string): Promise<Interrupt>;
+    getInterrupt(endpointConfig: EndpointConfig | null, interruptId: string, authProvider?: AuthProvider): Promise<Interrupt>;
     /**
      * Resolve an interrupt with user response
      *
@@ -78,28 +84,28 @@ export declare class InterruptService {
      * @param value - The user's response value
      * @returns The updated interrupt
      */
-    resolveInterrupt(interruptId: string, value: unknown): Promise<Interrupt>;
+    resolveInterrupt(endpointConfig: EndpointConfig | null, interruptId: string, value: unknown, authProvider?: AuthProvider): Promise<Interrupt>;
     /**
      * Cancel a pending interrupt
      *
      * @param interruptId - The interrupt UUID
      * @returns The updated interrupt
      */
-    cancelInterrupt(interruptId: string): Promise<Interrupt>;
+    cancelInterrupt(endpointConfig: EndpointConfig | null, interruptId: string, authProvider?: AuthProvider): Promise<Interrupt>;
     /**
      * List interrupts for a playground session
      *
      * @param sessionId - The session UUID
      * @returns Array of interrupts for the session
      */
-    listSessionInterrupts(sessionId: string): Promise<Interrupt[]>;
+    listSessionInterrupts(endpointConfig: EndpointConfig | null, sessionId: string, authProvider?: AuthProvider): Promise<Interrupt[]>;
     /**
      * List interrupts for a pipeline
      *
      * @param pipelineId - The pipeline UUID
      * @returns Array of interrupts for the pipeline
      */
-    listPipelineInterrupts(pipelineId: string): Promise<Interrupt[]>;
+    listPipelineInterrupts(endpointConfig: EndpointConfig | null, pipelineId: string, authProvider?: AuthProvider): Promise<Interrupt[]>;
     /**
      * Start polling for interrupts in a session
      *
@@ -109,7 +115,7 @@ export declare class InterruptService {
      * @param sessionId - The session UUID to poll
      * @param callback - Callback function to handle new interrupts
      */
-    startPolling(sessionId: string, callback: (interrupts: Interrupt[]) => void): void;
+    startPolling(endpointConfig: EndpointConfig | null, sessionId: string, callback: (interrupts: Interrupt[]) => void, authProvider?: AuthProvider): void;
     /**
      * Stop polling for interrupts
      */

package/dist/services/interruptService.js

@@ -8,8 +8,8 @@
  * @module services/interruptService
  */
 import { defaultInterruptPollingConfig } from '../types/interrupt.js';
-import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
-import { getEndpointConfig } from './api.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 import { logger } from '../utils/logger.js';
 /**
  * Interrupt Service class
@@ -62,22 +62,23 @@ export class InterruptService {
     /**
      * Check if interrupt endpoints are configured
      *
+     * @param config - The instance's endpoint configuration (from fd.api.config)
      * @returns True if interrupt endpoints are available
      */
-    isConfigured() {
-        const config = getEndpointConfig();
+    isConfigured(config) {
         return Boolean(config?.endpoints?.interrupts);
     }
     /**
-     * Get the endpoint configuration
+     * Validate and return the caller-supplied endpoint configuration.
      *
-     * @throws Error if endpoint configuration is not set
+     * Callers thread the config from `getInstance().api.config`.
+     *
+     * @throws Error if endpoint configuration is not set or lacks interrupts
      * @returns The endpoint configuration
      */
-    getConfig() {
-        const config = getEndpointConfig();
+    getConfig(config) {
         if (!config) {
-            throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
+            throw new Error('Endpoint configuration not set. Configure the instance via fd.api.configure().');
         }
         if (!config.endpoints.interrupts) {
             throw new Error('Interrupt endpoints not configured.');
@@ -87,19 +88,16 @@ export class InterruptService {
     /**
      * Generic API request helper
      *
+     * @param config - The endpoint configuration
      * @param url - The URL to fetch
      * @param options - Fetch options
      * @returns The parsed JSON response
      */
-    async request(url, options = {}) {
-        const config = this.getConfig();
-        const headers = getEndpointHeaders(config, 'interrupts');
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                ...headers,
-                ...options.headers
-            }
+    async request(config, url, options = {}, authProvider) {
+        const response = await authenticatedFetch(url, options, {
+            config,
+            endpointKey: 'interrupts',
+            authProvider
         });
         if (!response.ok) {
             const errorData = await response.json().catch(() => ({}));
@@ -119,12 +117,12 @@ export class InterruptService {
      * @param interruptId - The interrupt UUID
      * @returns The interrupt details
      */
-    async getInterrupt(interruptId) {
-        const config = this.getConfig();
+    async getInterrupt(endpointConfig, interruptId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.get, {
             interruptId
         });
-        const response = await this.request(url);
+        const response = await this.request(config, url, {}, authProvider);
         if (!response.data) {
             throw new Error('Interrupt not found');
         }
@@ -137,16 +135,16 @@ export class InterruptService {
      * @param value - The user's response value
      * @returns The updated interrupt
      */
-    async resolveInterrupt(interruptId, value) {
-        const config = this.getConfig();
+    async resolveInterrupt(endpointConfig, interruptId, value, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.resolve, {
             interruptId
         });
         const resolution = { value };
-        const response = await this.request(url, {
+        const response = await this.request(config, url, {
             method: 'POST',
             body: JSON.stringify(resolution)
-        });
+        }, authProvider);
         if (!response.data) {
             throw new Error('Failed to resolve interrupt: No data returned');
         }
@@ -158,14 +156,14 @@ export class InterruptService {
      * @param interruptId - The interrupt UUID
      * @returns The updated interrupt
      */
-    async cancelInterrupt(interruptId) {
-        const config = this.getConfig();
+    async cancelInterrupt(endpointConfig, interruptId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.cancel, {
             interruptId
         });
-        const response = await this.request(url, {
+        const response = await this.request(config, url, {
             method: 'POST'
-        });
+        }, authProvider);
         if (!response.data) {
             throw new Error('Failed to cancel interrupt: No data returned');
         }
@@ -177,12 +175,12 @@ export class InterruptService {
      * @param sessionId - The session UUID
      * @returns Array of interrupts for the session
      */
-    async listSessionInterrupts(sessionId) {
-        const config = this.getConfig();
+    async listSessionInterrupts(endpointConfig, sessionId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.listBySession, {
             sessionId
         });
-        const response = await this.request(url);
+        const response = await this.request(config, url, {}, authProvider);
         return response.data ?? [];
     }
     /**
@@ -191,12 +189,12 @@ export class InterruptService {
      * @param pipelineId - The pipeline UUID
      * @returns Array of interrupts for the pipeline
      */
-    async listPipelineInterrupts(pipelineId) {
-        const config = this.getConfig();
+    async listPipelineInterrupts(endpointConfig, pipelineId, authProvider) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.interrupts.listByPipeline, {
             pipelineId
         });
-        const response = await this.request(url);
+        const response = await this.request(config, url, {}, authProvider);
         return response.data ?? [];
     }
     // =========================================================================
@@ -211,7 +209,7 @@ export class InterruptService {
      * @param sessionId - The session UUID to poll
      * @param callback - Callback function to handle new interrupts
      */
-    startPolling(sessionId, callback) {
+    startPolling(endpointConfig, sessionId, callback, authProvider) {
         if (!this.pollingConfig.enabled) {
             logger.warn('[InterruptService] Polling is disabled. Enable via setPollingConfig().');
             return;
@@ -225,7 +223,7 @@ export class InterruptService {
                 return;
             }
             try {
-                const interrupts = await this.listSessionInterrupts(sessionId);
+                const interrupts = await this.listSessionInterrupts(endpointConfig, sessionId, authProvider);
                 const pendingInterrupts = interrupts.filter((i) => i.status === 'pending');
                 // Reset backoff on successful request
                 this.currentBackoff = this.pollingConfig.interval ?? defaultInterruptPollingConfig.interval;

package/dist/services/nodeExecutionService.d.ts

@@ -3,6 +3,7 @@
  * Handles fetching and managing node execution information from the backend
  */
 import type { NodeExecutionInfo } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Service for managing node execution information
  */
@@ -18,15 +19,15 @@ export declare class NodeExecutionService {
     /**
      * Get execution information for a specific node from pipeline data
      */
-    getNodeExecutionInfo(nodeId: string, pipelineId?: string): Promise<NodeExecutionInfo | null>;
+    getNodeExecutionInfo(endpointConfig: EndpointConfig | null, nodeId: string, pipelineId?: string): Promise<NodeExecutionInfo | null>;
     /**
      * Get execution information for multiple nodes from pipeline data
      */
-    getMultipleNodeExecutionInfo(nodeIds: string[], pipelineId?: string): Promise<Record<string, NodeExecutionInfo>>;
+    getMultipleNodeExecutionInfo(endpointConfig: EndpointConfig | null, nodeIds: string[], pipelineId?: string): Promise<Record<string, NodeExecutionInfo>>;
     /**
      * Get all node execution counts
      */
-    getAllNodeExecutionCounts(): Promise<Record<string, number>>;
+    getAllNodeExecutionCounts(endpointConfig: EndpointConfig | null): Promise<Record<string, number>>;
     /**
      * Get cached execution info for a node
      */
@@ -47,6 +48,20 @@ export declare class NodeExecutionService {
      * Update execution info for a node (for real-time updates)
      */
     updateNodeExecutionInfo(nodeId: string, executionInfo: Partial<NodeExecutionInfo>): void;
+    /**
+     * Build execution info for one node from the pipeline payload.
+     *
+     * The `node_statuses` entry is the backend-resolved summary (latest job's
+     * status, timing from the most recent run, `executions` count); the per-job
+     * history is attached from the `jobs` array so loop iterations stay
+     * inspectable. Falls back to the node's jobs when no entry exists (older
+     * backends).
+     */
+    private buildNodeExecutionInfo;
+    /**
+     * Map a pipeline job payload entry to a NodeJobExecution history item.
+     */
+    private mapJobToNodeJobExecution;
     /**
      * Map job status to execution status
      */