@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.1

package/dist/services/nodeExecutionService.js

@@ -2,7 +2,6 @@
  * Node Execution Service
  * Handles fetching and managing node execution information from the backend
  */
-import { getEndpointConfig } from './api.js';
 import { buildEndpointUrl } from '../config/endpoints.js';
 import { NODE_EXECUTION_CACHE_TIMEOUT_MS, PIPELINE_API_UNAVAILABLE_DURATION_MS } from '../config/constants.js';
 import { logger } from '../utils/logger.js';
@@ -26,12 +25,11 @@ export class NodeExecutionService {
     /**
      * Get execution information for a specific node from pipeline data
      */
-    async getNodeExecutionInfo(nodeId, pipelineId) {
+    async getNodeExecutionInfo(endpointConfig, nodeId, pipelineId) {
         if (!pipelineId) {
             return null;
         }
         try {
-            const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
                 throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
@@ -45,24 +43,7 @@ export class NodeExecutionService {
             const pipelineData = raw.data ?? raw;
             const jobs = pipelineData.jobs || [];
             const nodeStatuses = pipelineData.node_statuses || {};
-            // Find the job for this node
-            const nodeJob = jobs.find((job) => job.node_id === nodeId);
-            const nodeStatus = nodeStatuses[nodeId];
-            if (!nodeJob && !nodeStatus) {
-                return {
-                    status: 'idle',
-                    executionCount: 0,
-                    isExecuting: false
-                };
-            }
-            const executionInfo = {
-                status: this.mapJobStatusToExecutionStatus(nodeStatus?.status || nodeJob?.status || 'idle'),
-                executionCount: nodeJob?.execution_count || 0,
-                isExecuting: nodeStatus?.status === 'running' || nodeJob?.status === 'running',
-                lastExecuted: nodeJob?.last_executed || nodeStatus?.last_executed,
-                lastExecutionDuration: nodeJob?.execution_time || nodeStatus?.execution_time,
-                lastError: nodeJob?.error || nodeStatus?.error
-            };
+            const executionInfo = this.buildNodeExecutionInfo(nodeId, nodeStatuses[nodeId], jobs);
             this.cache.set(nodeId, executionInfo);
             return executionInfo;
         }
@@ -74,7 +55,7 @@ export class NodeExecutionService {
     /**
      * Get execution information for multiple nodes from pipeline data
      */
-    async getMultipleNodeExecutionInfo(nodeIds, pipelineId) {
+    async getMultipleNodeExecutionInfo(endpointConfig, nodeIds, pipelineId) {
         if (!pipelineId) {
             return {};
         }
@@ -91,7 +72,6 @@ export class NodeExecutionService {
             return defaultExecutionInfo;
         }
         try {
-            const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
                 throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
@@ -120,28 +100,11 @@ export class NodeExecutionService {
             const raw = await response.json();
             const result = raw.data ?? raw;
             const jobs = result.jobs || [];
+            const nodeStatuses = result.node_statuses || {};
             const executionInfoMap = {};
-            // Initialize all nodes with default values
             nodeIds.forEach((nodeId) => {
-                executionInfoMap[nodeId] = {
-                    status: 'idle',
-                    executionCount: 0,
-                    isExecuting: false
-                };
-            });
-            // Update with actual job data
-            jobs.forEach((job) => {
-                const nodeId = job.node_id;
-                if (nodeIds.includes(nodeId)) {
-                    executionInfoMap[nodeId] = {
-                        status: this.mapJobStatusToExecutionStatus(job.status),
-                        executionCount: job.execution_count || 0,
-                        isExecuting: job.status === 'running',
-                        lastExecuted: job.completed || job.started,
-                        lastExecutionDuration: job.execution_time,
-                        lastError: job.error_message
-                    };
-                    // Update cache
+                executionInfoMap[nodeId] = this.buildNodeExecutionInfo(nodeId, nodeStatuses[nodeId], jobs);
+                if (executionInfoMap[nodeId].status !== 'idle' || executionInfoMap[nodeId].jobs) {
                     this.cache.set(nodeId, executionInfoMap[nodeId]);
                 }
             });
@@ -164,9 +127,8 @@ export class NodeExecutionService {
     /**
      * Get all node execution counts
      */
-    async getAllNodeExecutionCounts() {
+    async getAllNodeExecutionCounts(endpointConfig) {
         try {
-            const endpointConfig = getEndpointConfig();
             if (!endpointConfig)
                 throw new Error('Endpoint config not available');
             const url = buildEndpointUrl(endpointConfig, '/node-execution-counts');
@@ -227,6 +189,66 @@ export class NodeExecutionService {
             });
         }
     }
+    /**
+     * 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).
+     */
+    buildNodeExecutionInfo(nodeId, entry, jobs) {
+        const nodeJobs = jobs.filter((job) => job.node_id === nodeId);
+        if (!entry && nodeJobs.length === 0) {
+            return {
+                status: 'idle',
+                executionCount: 0,
+                isExecuting: false
+            };
+        }
+        // Fallback for payloads without a node_statuses entry: the last job in
+        // pipeline order mirrors the backend's latest-wins resolution.
+        const lastJob = nodeJobs[nodeJobs.length - 1];
+        const status = entry?.status ?? lastJob?.status ?? 'idle';
+        const startedCount = nodeJobs.filter((job) => job.started).length;
+        const executionInfo = {
+            status: this.mapJobStatusToExecutionStatus(status),
+            executionCount: entry?.executions ?? startedCount,
+            isExecuting: status === 'running' || nodeJobs.some((job) => job.status === 'running'),
+            lastExecuted: entry?.last_executed ?? lastJob?.completed ?? lastJob?.started ?? undefined,
+            lastExecutionDuration: entry?.execution_time ?? lastJob?.execution_time ?? undefined,
+            lastExecutionDurationUs: entry?.execution_time_us ?? lastJob?.execution_time_us ?? undefined,
+            lastError: entry?.error ?? lastJob?.error_message ?? undefined
+        };
+        if (nodeJobs.length > 0) {
+            executionInfo.jobs = nodeJobs.map((job) => this.mapJobToNodeJobExecution(job));
+        }
+        return executionInfo;
+    }
+    /**
+     * Map a pipeline job payload entry to a NodeJobExecution history item.
+     */
+    mapJobToNodeJobExecution(job) {
+        let executionTime = job.execution_time;
+        if (executionTime == null && job.started && job.completed) {
+            const started = Date.parse(job.started);
+            const completed = Date.parse(job.completed);
+            if (!Number.isNaN(started) && !Number.isNaN(completed)) {
+                executionTime = completed - started;
+            }
+        }
+        return {
+            id: job.id,
+            label: job.label,
+            status: this.mapJobStatusToExecutionStatus(job.status),
+            started: job.started,
+            completed: job.completed,
+            executionTime,
+            executionTimeUs: job.execution_time_us ?? (executionTime != null ? executionTime * 1000 : undefined),
+            error: job.error_message ?? job.error
+        };
+    }
     /**
      * Map job status to execution status
      */
@@ -244,6 +266,10 @@ export class NodeExecutionService {
                 return 'cancelled';
             case 'skipped':
                 return 'skipped';
+            case 'paused':
+                return 'paused';
+            case 'interrupted':
+                return 'interrupted';
             default:
                 return 'idle';
         }

package/dist/services/playgroundService.d.ts

@@ -7,6 +7,7 @@
  * @module services/playgroundService
  */
 import type { PlaygroundSession, PlaygroundMessage, PlaygroundMessagesApiResponse, PlaygroundSessionStatus } from '../types/playground.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Pagination options for {@link PlaygroundService.getMessages}.
  * `since`, `before`, and `latest` are mutually exclusive.
@@ -41,7 +42,10 @@ export declare class PlaygroundService {
      */
     static getInstance(): PlaygroundService;
     /**
-     * Get the endpoint configuration
+     * Validate and return the endpoint configuration passed by the caller.
+     *
+     * Callers thread the config from `getInstance().api.config`; this enforces
+     * the legacy "throws if not configured" contract.
      *
      * @throws Error if endpoint configuration is not set
      * @returns The endpoint configuration
@@ -50,6 +54,7 @@ export declare class PlaygroundService {
     /**
      * Generic API request helper
      *
+     * @param config - The endpoint configuration
      * @param url - The URL to fetch
      * @param options - Fetch options
      * @returns The parsed JSON response
@@ -62,7 +67,7 @@ export declare class PlaygroundService {
      * @param options - Optional pagination parameters
      * @returns Array of playground sessions
      */
-    listSessions(workflowId: string, options?: {
+    listSessions(endpointConfig: EndpointConfig | null, workflowId: string, options?: {
         limit?: number;
         offset?: number;
     }): Promise<PlaygroundSession[]>;
@@ -74,20 +79,20 @@ export declare class PlaygroundService {
      * @param metadata - Optional session metadata
      * @returns The created session
      */
-    createSession(workflowId: string, name?: string, metadata?: Record<string, unknown>): Promise<PlaygroundSession>;
+    createSession(endpointConfig: EndpointConfig | null, workflowId: string, name?: string, metadata?: Record<string, unknown>): Promise<PlaygroundSession>;
     /**
      * Get a playground session by ID
      *
      * @param sessionId - The session UUID
      * @returns The session details
      */
-    getSession(sessionId: string): Promise<PlaygroundSession>;
+    getSession(endpointConfig: EndpointConfig | null, sessionId: string): Promise<PlaygroundSession>;
     /**
      * Delete a playground session
      *
      * @param sessionId - The session UUID
      */
-    deleteSession(sessionId: string): Promise<void>;
+    deleteSession(endpointConfig: EndpointConfig | null, sessionId: string): Promise<void>;
     /**
      * Get messages from a playground session.
      *
@@ -101,7 +106,7 @@ export declare class PlaygroundService {
      * @param options - Pagination options
      * @returns Messages and session status
      */
-    getMessages(sessionId: string, options?: GetMessagesOptions): Promise<PlaygroundMessagesApiResponse>;
+    getMessages(endpointConfig: EndpointConfig | null, sessionId: string, options?: GetMessagesOptions): Promise<PlaygroundMessagesApiResponse>;
     /**
      * Send a message to a playground session
      *
@@ -110,13 +115,13 @@ export declare class PlaygroundService {
      * @param inputs - Optional additional inputs for workflow nodes
      * @returns The created message
      */
-    sendMessage(sessionId: string, content: string, inputs?: Record<string, unknown>): Promise<PlaygroundMessage>;
+    sendMessage(endpointConfig: EndpointConfig | null, sessionId: string, content: string, inputs?: Record<string, unknown>): Promise<PlaygroundMessage>;
     /**
      * Stop execution in a playground session
      *
      * @param sessionId - The session UUID
      */
-    stopExecution(sessionId: string): Promise<void>;
+    stopExecution(endpointConfig: EndpointConfig | null, sessionId: string): Promise<void>;
     /**
      * Start polling for new messages
      *
@@ -126,7 +131,7 @@ export declare class PlaygroundService {
      * @param shouldStopPolling - Optional override for stop conditions (default: defaultShouldStopPolling)
      * @param initialSequenceNumber - Optional sequence number to seed polling from (avoids re-fetching already loaded messages)
      */
-    startPolling(sessionId: string, callback: (response: PlaygroundMessagesApiResponse) => void, interval?: number, shouldStopPolling?: (status: PlaygroundSessionStatus) => boolean, initialSequenceNumber?: number | null): void;
+    startPolling(endpointConfig: EndpointConfig | null, sessionId: string, callback: (response: PlaygroundMessagesApiResponse) => void, interval?: number, shouldStopPolling?: (status: PlaygroundSessionStatus) => boolean, initialSequenceNumber?: number | null): void;
     /**
      * Stop polling for messages
      */

package/dist/services/playgroundService.js

@@ -8,7 +8,6 @@
  */
 import { defaultShouldStopPolling } from '../types/playground.js';
 import { buildEndpointUrl, getEndpointHeaders } from '../config/endpoints.js';
-import { getEndpointConfig } from './api.js';
 import { logger } from '../utils/logger.js';
 /**
  * Default polling interval in milliseconds
@@ -43,27 +42,29 @@ export class PlaygroundService {
         return PlaygroundService.instance;
     }
     /**
-     * Get the endpoint configuration
+     * Validate and return the endpoint configuration passed by the caller.
+     *
+     * Callers thread the config from `getInstance().api.config`; this enforces
+     * the legacy "throws if not configured" contract.
      *
      * @throws Error if endpoint configuration is not set
      * @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().');
         }
         return config;
     }
     /**
      * 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();
+    async request(config, url, options = {}) {
         const headers = getEndpointHeaders(config, 'playground');
         const response = await fetch(url, {
             ...options,
@@ -91,8 +92,8 @@ export class PlaygroundService {
      * @param options - Optional pagination parameters
      * @returns Array of playground sessions
      */
-    async listSessions(workflowId, options) {
-        const config = this.getConfig();
+    async listSessions(endpointConfig, workflowId, options) {
+        const config = this.getConfig(endpointConfig);
         let url = buildEndpointUrl(config, config.endpoints.playground.listSessions, {
             id: workflowId
         });
@@ -108,7 +109,7 @@ export class PlaygroundService {
         if (queryString) {
             url = `${url}?${queryString}`;
         }
-        const response = await this.request(url);
+        const response = await this.request(config, url);
         return response.data ?? [];
     }
     /**
@@ -119,12 +120,12 @@ export class PlaygroundService {
      * @param metadata - Optional session metadata
      * @returns The created session
      */
-    async createSession(workflowId, name, metadata) {
-        const config = this.getConfig();
+    async createSession(endpointConfig, workflowId, name, metadata) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.createSession, {
             id: workflowId
         });
-        const response = await this.request(url, {
+        const response = await this.request(config, url, {
             method: 'POST',
             body: JSON.stringify({ name, metadata })
         });
@@ -139,12 +140,12 @@ export class PlaygroundService {
      * @param sessionId - The session UUID
      * @returns The session details
      */
-    async getSession(sessionId) {
-        const config = this.getConfig();
+    async getSession(endpointConfig, sessionId) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.getSession, {
             sessionId
         });
-        const response = await this.request(url);
+        const response = await this.request(config, url);
         if (!response.data) {
             throw new Error('Session not found');
         }
@@ -155,12 +156,12 @@ export class PlaygroundService {
      *
      * @param sessionId - The session UUID
      */
-    async deleteSession(sessionId) {
-        const config = this.getConfig();
+    async deleteSession(endpointConfig, sessionId) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.deleteSession, {
             sessionId
         });
-        await this.request(url, {
+        await this.request(config, url, {
             method: 'DELETE'
         });
     }
@@ -180,8 +181,8 @@ export class PlaygroundService {
      * @param options - Pagination options
      * @returns Messages and session status
      */
-    async getMessages(sessionId, options = {}) {
-        const config = this.getConfig();
+    async getMessages(endpointConfig, sessionId, options = {}) {
+        const config = this.getConfig(endpointConfig);
         let url = buildEndpointUrl(config, config.endpoints.playground.getMessages, {
             sessionId
         });
@@ -202,7 +203,7 @@ export class PlaygroundService {
         if (queryString) {
             url = `${url}?${queryString}`;
         }
-        return this.request(url);
+        return this.request(config, url);
     }
     /**
      * Send a message to a playground session
@@ -212,8 +213,8 @@ export class PlaygroundService {
      * @param inputs - Optional additional inputs for workflow nodes
      * @returns The created message
      */
-    async sendMessage(sessionId, content, inputs) {
-        const config = this.getConfig();
+    async sendMessage(endpointConfig, sessionId, content, inputs) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.sendMessage, {
             sessionId
         });
@@ -221,7 +222,7 @@ export class PlaygroundService {
         if (inputs) {
             requestBody.inputs = inputs;
         }
-        const response = await this.request(url, {
+        const response = await this.request(config, url, {
             method: 'POST',
             body: JSON.stringify(requestBody)
         });
@@ -235,12 +236,12 @@ export class PlaygroundService {
      *
      * @param sessionId - The session UUID
      */
-    async stopExecution(sessionId) {
-        const config = this.getConfig();
+    async stopExecution(endpointConfig, sessionId) {
+        const config = this.getConfig(endpointConfig);
         const url = buildEndpointUrl(config, config.endpoints.playground.stopExecution, {
             sessionId
         });
-        await this.request(url, {
+        await this.request(config, url, {
             method: 'POST'
         });
     }
@@ -256,7 +257,7 @@ export class PlaygroundService {
      * @param shouldStopPolling - Optional override for stop conditions (default: defaultShouldStopPolling)
      * @param initialSequenceNumber - Optional sequence number to seed polling from (avoids re-fetching already loaded messages)
      */
-    startPolling(sessionId, callback, interval = DEFAULT_POLLING_INTERVAL, shouldStopPolling, initialSequenceNumber) {
+    startPolling(endpointConfig, sessionId, callback, interval = DEFAULT_POLLING_INTERVAL, shouldStopPolling, initialSequenceNumber) {
         // Stop any existing polling
         this.stopPolling();
         this.pollingSessionId = sessionId;
@@ -268,7 +269,7 @@ export class PlaygroundService {
                 return;
             }
             try {
-                const response = await this.getMessages(sessionId, {
+                const response = await this.getMessages(endpointConfig, sessionId, {
                     since: this.lastSequenceNumber ?? undefined
                 });
                 // Update last sequence number cursor

package/dist/services/variableService.d.ts

@@ -6,6 +6,7 @@
  * @module services/variableService
  */
 import type { WorkflowNode, WorkflowEdge, VariableSchema, TemplateVariable, TemplateVariablesConfig, AuthProvider } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Options for deriving available variables.
  */
@@ -138,4 +139,4 @@ export declare function mergeVariableSchemas(primary: VariableSchema, secondary:
  * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
  * ```
  */
-export declare function getVariableSchema(node: WorkflowNode, nodes: WorkflowNode[], edges: WorkflowEdge[], config: TemplateVariablesConfig, workflowId?: string, authProvider?: AuthProvider): Promise<VariableSchema>;
+export declare function getVariableSchema(endpointConfig: EndpointConfig | null, node: WorkflowNode, nodes: WorkflowNode[], edges: WorkflowEdge[], config: TemplateVariablesConfig, workflowId?: string, authProvider?: AuthProvider): Promise<VariableSchema>;

package/dist/services/variableService.js

@@ -405,14 +405,14 @@ export function mergeVariableSchemas(primary, secondary) {
  * const schema = await getVariableSchema(node, nodes, edges, config, workflowId, authProvider);
  * ```
  */
-export async function getVariableSchema(node, nodes, edges, config, workflowId, authProvider) {
+export async function getVariableSchema(endpointConfig, node, nodes, edges, config, workflowId, authProvider) {
     let resultSchema = { variables: {} };
     // Try API mode first (if configured)
     if (config.api) {
         try {
             // Import API variable service dynamically to avoid circular dependencies
             const { fetchVariableSchema } = await import('./apiVariableService.js');
-            const apiResult = await fetchVariableSchema(workflowId, node.id, config.api, authProvider);
+            const apiResult = await fetchVariableSchema(endpointConfig, workflowId, node.id, config.api, authProvider);
             if (apiResult.success && apiResult.schema) {
                 resultSchema = apiResult.schema;
                 // Merge with static schema if configured

package/dist/services/workflowStorage.js

@@ -20,10 +20,10 @@ export async function saveWorkflow(workflow) {
         ...workflow,
         id,
         metadata: {
-            version: '1.0.0',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            ...workflow.metadata
+            ...workflow.metadata,
+            schemaVersion: workflow.metadata?.schemaVersion ?? '1.0.0',
+            createdAt: workflow.metadata?.createdAt ?? new Date().toISOString(),
+            updatedAt: workflow.metadata?.updatedAt ?? new Date().toISOString()
         }
     };
     workflows.set(id, newWorkflow);
@@ -42,7 +42,7 @@ export async function updateWorkflow(id, workflow) {
         ...workflow,
         id, // Ensure ID doesn't change
         metadata: {
-            version: existing.metadata?.version || '1.0.0',
+            schemaVersion: existing.metadata?.schemaVersion || '1.0.0',
             createdAt: existing.metadata?.createdAt || new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             author: workflow.metadata?.author || existing.metadata?.author,
@@ -105,7 +105,7 @@ export async function initializeSampleWorkflows() {
         nodes: [],
         edges: [],
         metadata: {
-            version: '1.0.0',
+            schemaVersion: '1.0.0',
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             author: 'System',

package/dist/stores/apiContext.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Per-instance API context for FlowDrop.
+ *
+ * Holds the endpoint configuration and auth provider for one FlowDrop
+ * instance and lazily exposes an {@link EnhancedFlowDropApiClient} built from
+ * them. Replaces the former module-level singleton in `services/api.ts`:
+ * each instance owns its own configuration so multiple editors can talk to
+ * different backends on a single page.
+ *
+ * Resolved in components via `getInstance().api`; configured at mount time by
+ * `mountFlowDropApp` / `mountPlayground` (or `<App>` when used directly).
+ *
+ * @module stores/apiContext
+ */
+import type { EndpointConfig } from '../config/endpoints.js';
+import type { AuthProvider } from '../types/auth.js';
+import { EnhancedFlowDropApiClient } from '../api/enhanced-client.js';
+/**
+ * Per-instance endpoint configuration, auth provider, and API client.
+ *
+ * The config is `null` until {@link configure} is called — mirroring the
+ * legacy "throws if not configured" contract. The client is created lazily on
+ * first access and rebuilt whenever the configuration changes.
+ */
+export declare class ApiContext {
+    #private;
+    /** The current endpoint configuration, or null until {@link configure}d. */
+    get config(): EndpointConfig | null;
+    /** The current auth provider (defaults to {@link NoAuthProvider}). */
+    get authProvider(): AuthProvider;
+    /**
+     * The API client for this instance, created lazily from the configured
+     * endpoints and auth provider.
+     *
+     * @throws Error if the context has not been configured yet.
+     */
+    get client(): EnhancedFlowDropApiClient;
+    /**
+     * Configure this instance's endpoints and (optionally) auth provider.
+     * Discards any previously built client so the next access rebuilds it.
+     */
+    configure(config: EndpointConfig, authProvider?: AuthProvider): void;
+    /** Whether {@link configure} has been called with a usable config. */
+    isConfigured(): boolean;
+}

package/dist/stores/apiContext.js

@@ -0,0 +1,65 @@
+/**
+ * Per-instance API context for FlowDrop.
+ *
+ * Holds the endpoint configuration and auth provider for one FlowDrop
+ * instance and lazily exposes an {@link EnhancedFlowDropApiClient} built from
+ * them. Replaces the former module-level singleton in `services/api.ts`:
+ * each instance owns its own configuration so multiple editors can talk to
+ * different backends on a single page.
+ *
+ * Resolved in components via `getInstance().api`; configured at mount time by
+ * `mountFlowDropApp` / `mountPlayground` (or `<App>` when used directly).
+ *
+ * @module stores/apiContext
+ */
+import { NoAuthProvider } from '../types/auth.js';
+import { EnhancedFlowDropApiClient } from '../api/enhanced-client.js';
+/**
+ * Per-instance endpoint configuration, auth provider, and API client.
+ *
+ * The config is `null` until {@link configure} is called — mirroring the
+ * legacy "throws if not configured" contract. The client is created lazily on
+ * first access and rebuilt whenever the configuration changes.
+ */
+export class ApiContext {
+    #config = null;
+    #authProvider = new NoAuthProvider();
+    #client = null;
+    /** The current endpoint configuration, or null until {@link configure}d. */
+    get config() {
+        return this.#config;
+    }
+    /** The current auth provider (defaults to {@link NoAuthProvider}). */
+    get authProvider() {
+        return this.#authProvider;
+    }
+    /**
+     * The API client for this instance, created lazily from the configured
+     * endpoints and auth provider.
+     *
+     * @throws Error if the context has not been configured yet.
+     */
+    get client() {
+        if (!this.#config) {
+            throw new Error('Endpoint configuration not set. Configure the instance via fd.api.configure() ' +
+                '(done automatically by mountFlowDropApp / <App>) before using fd.api.client.');
+        }
+        return (this.#client ??= new EnhancedFlowDropApiClient(this.#config, this.#authProvider));
+    }
+    /**
+     * Configure this instance's endpoints and (optionally) auth provider.
+     * Discards any previously built client so the next access rebuilds it.
+     */
+    configure(config, authProvider) {
+        this.#config = config;
+        if (authProvider) {
+            this.#authProvider = authProvider;
+        }
+        // Drop the cached client so it picks up the new config/auth on next access.
+        this.#client = null;
+    }
+    /** Whether {@link configure} has been called with a usable config. */
+    isConfigured() {
+        return Boolean(this.#config);
+    }
+}