@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/registry/nodeComponentRegistry.js

@@ -8,7 +8,17 @@
  * - External libraries to contribute node types via plugins
  * - Runtime switching between different node visualizations
  */
-import { BaseRegistry } from './BaseRegistry.js';
+import { BaseRegistry } from './BaseRegistry.svelte.js';
+/**
+ * Check if a namespace is valid.
+ * Must be lowercase alphanumeric with optional hyphens.
+ *
+ * @param namespace - The namespace to validate
+ * @returns true if valid
+ */
+export function isValidNamespace(namespace) {
+    return /^[a-z][a-z0-9-]*$/.test(namespace);
+}
 /**
  * Central registry for node component types.
  * Allows built-in and third-party components to be registered and resolved.
@@ -18,7 +28,7 @@ import { BaseRegistry } from './BaseRegistry.js';
  * @example
  * ```typescript
  * // Register a custom node
- * nodeComponentRegistry.register({
+ * fd.nodes.register({
  *     type: "myCustomNode",
  *     displayName: "My Custom Node",
  *     component: MyCustomNodeComponent,
@@ -27,14 +37,37 @@ import { BaseRegistry } from './BaseRegistry.js';
  * });
  *
  * // Get a component
- * const component = nodeComponentRegistry.getComponent("myCustomNode");
+ * const component = fd.nodes.getComponent("myCustomNode");
  * ```
  */
-class NodeComponentRegistry extends BaseRegistry {
+export class NodeComponentRegistry extends BaseRegistry {
     /** Default type to use when requested type is not found */
     defaultType = 'workflowNode';
     /** Initial default type, restored on clear() */
     static INITIAL_DEFAULT_TYPE = 'workflowNode';
+    /**
+     * @param seed - Optional initial registrations and default type. When
+     *   omitted the registry starts empty; instances created via
+     *   `createFlowDropInstance` pass the built-in node components (see
+     *   `builtinNodes.ts`).
+     */
+    constructor(seed) {
+        super();
+        if (seed?.registrations) {
+            this.registerAll(seed.registrations, true);
+        }
+        if (seed?.defaultType) {
+            this.defaultType = seed.defaultType;
+        }
+    }
+    /**
+     * Clear all registrations and reset default type.
+     */
+    clear() {
+        super.clear();
+        this.defaultType = NodeComponentRegistry.INITIAL_DEFAULT_TYPE;
+        this.touch(); // defaultType changed — invalidate getComponent/getDefaultType reads
+    }
     /**
      * Register a node component type.
      *
@@ -44,7 +77,7 @@ class NodeComponentRegistry extends BaseRegistry {
      *
      * @example
      * ```typescript
-     * nodeComponentRegistry.register({
+     * fd.nodes.register({
      *     type: "fancy",
      *     displayName: "Fancy Node",
      *     component: FancyNode,
@@ -52,19 +85,13 @@ class NodeComponentRegistry extends BaseRegistry {
      * });
      * ```
      */
-    /**
-     * Clear all registrations and reset default type.
-     */
-    clear() {
-        super.clear();
-        this.defaultType = NodeComponentRegistry.INITIAL_DEFAULT_TYPE;
-    }
     register(registration, overwrite = false) {
         if (this.items.has(registration.type) && !overwrite) {
             throw new Error(`Node type "${registration.type}" is already registered. ` +
                 `Use overwrite: true to replace it, or use a namespaced type like "mylib:${registration.type}".`);
         }
         this.items.set(registration.type, registration);
+        this.touch();
         this.notifyListeners();
     }
     /**
@@ -86,6 +113,7 @@ class NodeComponentRegistry extends BaseRegistry {
      * @returns The component if found, or the default component
      */
     getComponent(type) {
+        this.trackVersion(); // reactive dependency (reads items + defaultType directly)
         const registration = this.items.get(type) ?? this.items.get(this.defaultType);
         return registration?.component;
     }
@@ -96,6 +124,7 @@ class NodeComponentRegistry extends BaseRegistry {
      * @returns The metadata if found, undefined otherwise
      */
     getMetadata(type) {
+        this.trackVersion(); // reactive dependency (reads items directly)
         const reg = this.items.get(type);
         if (!reg)
             return undefined;
@@ -119,10 +148,10 @@ class NodeComponentRegistry extends BaseRegistry {
      * @example
      * ```typescript
      * // Get all visual nodes
-     * const visualNodes = nodeComponentRegistry.filter({ category: "visual" });
+     * const visualNodes = fd.nodes.filter({ category: "visual" });
      *
      * // Get nodes from a specific library
-     * const libNodes = nodeComponentRegistry.filter({ source: "mylib" });
+     * const libNodes = fd.nodes.filter({ source: "mylib" });
      * ```
      */
     filter(filter) {
@@ -168,6 +197,7 @@ class NodeComponentRegistry extends BaseRegistry {
             throw new Error(`Cannot set default to unregistered type: ${type}`);
         }
         this.defaultType = type;
+        this.touch(); // defaultType changed — invalidate getComponent/getDefaultType reads
     }
     /**
      * Get the current default type.
@@ -175,6 +205,7 @@ class NodeComponentRegistry extends BaseRegistry {
      * @returns The default type identifier
      */
     getDefaultType() {
+        this.trackVersion(); // reactive dependency (reads defaultType directly)
         return this.defaultType;
     }
     /**
@@ -186,7 +217,7 @@ class NodeComponentRegistry extends BaseRegistry {
      *
      * @example
      * ```typescript
-     * const oneOf = nodeComponentRegistry.getOneOfOptions();
+     * const oneOf = fd.nodes.getOneOfOptions();
      * // Use in configSchema: { type: "string", oneOf }
      * ```
      */
@@ -204,6 +235,7 @@ class NodeComponentRegistry extends BaseRegistry {
      * @returns The status position, or default "top-right"
      */
     getStatusPosition(type) {
+        this.trackVersion(); // reactive dependency (reads items directly)
         return this.items.get(type)?.statusPosition ?? 'top-right';
     }
     /**
@@ -213,11 +245,197 @@ class NodeComponentRegistry extends BaseRegistry {
      * @returns The status size, or default "md"
      */
     getStatusSize(type) {
+        this.trackVersion(); // reactive dependency (reads items directly)
         return this.items.get(type)?.statusSize ?? 'md';
     }
+    // ==========================================================================
+    // Plugin system
+    // ==========================================================================
+    /**
+     * Register a single custom node without a full plugin.
+     * Useful for project-specific custom nodes.
+     *
+     * @param type - Type identifier (can be namespaced or plain)
+     * @param displayName - Display name for UI
+     * @param component - Svelte component
+     * @param options - Additional options
+     *
+     * @example
+     * ```typescript
+     * fd.nodes.registerCustom("myproject:special", "Special Node", MyNode, {
+     *     icon: "mdi:star",
+     *     description: "A special node for my project"
+     * });
+     * ```
+     */
+    registerCustom(type, displayName, component, options = {}) {
+        this.register({
+            type,
+            displayName,
+            component,
+            description: options.description,
+            icon: options.icon,
+            category: options.category ?? 'custom',
+            source: options.source ?? 'custom',
+            statusPosition: options.statusPosition,
+            statusSize: options.statusSize
+        });
+    }
+    /**
+     * Register a FlowDrop plugin with custom node components.
+     * All node types are automatically namespaced with the plugin namespace.
+     *
+     * @param config - Plugin configuration with namespace and node definitions
+     * @returns Result object with registered types and any errors
+     */
+    registerPlugin(config) {
+        const result = {
+            success: true,
+            namespace: config.namespace,
+            registeredTypes: [],
+            errors: []
+        };
+        // Validate namespace
+        if (!isValidNamespace(config.namespace)) {
+            result.success = false;
+            result.errors.push(`Invalid namespace "${config.namespace}". ` +
+                `Namespace must be lowercase alphanumeric with optional hyphens.`);
+            return result;
+        }
+        // Register each node
+        for (const nodeDef of config.nodes) {
+            try {
+                const namespacedType = createNamespacedType(config.namespace, nodeDef.type);
+                const registration = {
+                    type: namespacedType,
+                    displayName: nodeDef.displayName,
+                    description: nodeDef.description,
+                    component: nodeDef.component,
+                    icon: nodeDef.icon,
+                    category: nodeDef.category ?? 'custom',
+                    source: config.namespace,
+                    statusPosition: nodeDef.statusPosition,
+                    statusSize: nodeDef.statusSize
+                };
+                this.register(registration);
+                result.registeredTypes.push(namespacedType);
+            }
+            catch (error) {
+                result.success = false;
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                result.errors.push(`Failed to register ${config.namespace}:${nodeDef.type}: ${errorMessage}`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Unregister all nodes from a plugin by namespace.
+     *
+     * @param namespace - The plugin namespace to unregister
+     * @returns Array of unregistered type identifiers
+     */
+    unregisterPlugin(namespace) {
+        const unregistered = [];
+        const types = this.getTypes();
+        for (const type of types) {
+            if (type.startsWith(`${namespace}:`)) {
+                if (this.unregister(type)) {
+                    unregistered.push(type);
+                }
+            }
+        }
+        return unregistered;
+    }
+    /**
+     * Get all registered plugins (unique namespaces).
+     *
+     * @returns Array of namespace strings
+     */
+    getRegisteredPlugins() {
+        const sources = new Set();
+        for (const reg of this.getAll()) {
+            if (reg.source && reg.source !== 'flowdrop') {
+                sources.add(reg.source);
+            }
+        }
+        return Array.from(sources);
+    }
+    /**
+     * Get the count of nodes registered by a plugin.
+     *
+     * @param namespace - The plugin namespace
+     * @returns Number of nodes registered by this plugin
+     */
+    getPluginNodeCount(namespace) {
+        return this.getBySource(namespace).length;
+    }
+}
+/**
+ * Create a plugin builder for a fluent API experience.
+ *
+ * @param namespace - Plugin namespace
+ * @param name - Plugin name
+ * @returns Plugin builder with chainable methods
+ *
+ * @example
+ * ```typescript
+ * import { createPlugin } from "@flowdrop/flowdrop/editor";
+ *
+ * createPlugin("awesome", "Awesome Nodes")
+ *     .version("1.0.0")
+ *     .node("fancy", "Fancy Node", FancyNode)
+ *     .node("glow", "Glowing Node", GlowNode, { icon: "mdi:lightbulb" })
+ *     .register(fd.nodes);
+ * ```
+ */
+export function createPlugin(namespace, name) {
+    const config = {
+        namespace,
+        name,
+        nodes: []
+    };
+    const builder = {
+        /**
+         * Set plugin version
+         */
+        version(v) {
+            config.version = v;
+            return builder;
+        },
+        /**
+         * Set plugin description
+         */
+        description(desc) {
+            config.description = desc;
+            return builder;
+        },
+        /**
+         * Add a node to the plugin
+         */
+        node(type, displayName, component, options = {}) {
+            config.nodes.push({
+                type,
+                displayName,
+                component,
+                ...options
+            });
+            return builder;
+        },
+        /**
+         * Register the plugin into a node component registry (e.g. `fd.nodes`).
+         */
+        register(registry) {
+            return registry.registerPlugin(config);
+        },
+        /**
+         * Get the config without registering (for testing/inspection)
+         */
+        getConfig() {
+            return { ...config };
+        }
+    };
+    return builder;
 }
-/** Singleton instance of the node component registry */
-export const nodeComponentRegistry = new NodeComponentRegistry();
 /**
  * Helper function to create a namespaced type identifier.
  * Use this to avoid conflicts when registering custom nodes.

package/dist/registry/workflowFormatRegistry.d.ts

@@ -13,7 +13,7 @@
  */
 import type { StandardWorkflow } from '../adapters/WorkflowAdapter.js';
 import type { NodeMetadata, WorkflowFormat } from '../types/index.js';
-import { BaseRegistry } from './BaseRegistry.js';
+import { BaseRegistry } from './BaseRegistry.svelte.js';
 /**
  * Validation result returned by format adapters.
  */
@@ -60,13 +60,15 @@ export interface WorkflowFormatAdapter {
     validate?(workflow: StandardWorkflow): FormatValidationResult;
 }
 /**
- * Central registry for workflow format adapters.
- * Singleton — extends BaseRegistry for shared mechanics.
+ * Per-instance registry for workflow format adapters.
+ * Extends BaseRegistry for shared mechanics; seeded with the built-in
+ * adapters at construction (see `createFlowDropInstance`). Reach it via
+ * `fd.formats`, or supply adapters through the `formatAdapters` mount option.
  *
  * @example
  * ```typescript
  * // Register a custom format
- * workflowFormatRegistry.register({
+ * fd.formats.register({
  *   id: 'n8n',
  *   name: 'n8n Workflow',
  *   export: (workflow) => JSON.stringify(convertToN8n(workflow)),
@@ -74,10 +76,16 @@ export interface WorkflowFormatAdapter {
  * });
  *
  * // Get an adapter
- * const adapter = workflowFormatRegistry.get('n8n');
+ * const adapter = fd.formats.get('n8n');
  * ```
  */
-declare class WorkflowFormatRegistry extends BaseRegistry<string, WorkflowFormatAdapter> {
+export declare class WorkflowFormatRegistry extends BaseRegistry<string, WorkflowFormatAdapter> {
+    /**
+     * @param seed - Optional initial format adapters. When omitted the registry
+     *   starts empty; instances created via `createFlowDropInstance` pass the
+     *   built-in flowdrop + agentspec adapters (see `builtinFormats.ts`).
+     */
+    constructor(seed?: WorkflowFormatAdapter[]);
     /**
      * Register a workflow format adapter.
      *
@@ -117,6 +125,3 @@ declare class WorkflowFormatRegistry extends BaseRegistry<string, WorkflowFormat
         title: string;
     }>;
 }
-/** Singleton instance of the workflow format registry */
-export declare const workflowFormatRegistry: WorkflowFormatRegistry;
-export {};

package/dist/registry/workflowFormatRegistry.js

@@ -11,15 +11,17 @@
  *
  * Extends BaseRegistry for shared mechanics (subscribe, onClear, etc.).
  */
-import { BaseRegistry } from './BaseRegistry.js';
+import { BaseRegistry } from './BaseRegistry.svelte.js';
 /**
- * Central registry for workflow format adapters.
- * Singleton — extends BaseRegistry for shared mechanics.
+ * Per-instance registry for workflow format adapters.
+ * Extends BaseRegistry for shared mechanics; seeded with the built-in
+ * adapters at construction (see `createFlowDropInstance`). Reach it via
+ * `fd.formats`, or supply adapters through the `formatAdapters` mount option.
  *
  * @example
  * ```typescript
  * // Register a custom format
- * workflowFormatRegistry.register({
+ * fd.formats.register({
  *   id: 'n8n',
  *   name: 'n8n Workflow',
  *   export: (workflow) => JSON.stringify(convertToN8n(workflow)),
@@ -27,10 +29,23 @@ import { BaseRegistry } from './BaseRegistry.js';
  * });
  *
  * // Get an adapter
- * const adapter = workflowFormatRegistry.get('n8n');
+ * const adapter = fd.formats.get('n8n');
  * ```
  */
-class WorkflowFormatRegistry extends BaseRegistry {
+export class WorkflowFormatRegistry extends BaseRegistry {
+    /**
+     * @param seed - Optional initial format adapters. When omitted the registry
+     *   starts empty; instances created via `createFlowDropInstance` pass the
+     *   built-in flowdrop + agentspec adapters (see `builtinFormats.ts`).
+     */
+    constructor(seed) {
+        super();
+        if (seed) {
+            for (const adapter of seed) {
+                this.register(adapter, true);
+            }
+        }
+    }
     /**
      * Register a workflow format adapter.
      *
@@ -44,6 +59,7 @@ class WorkflowFormatRegistry extends BaseRegistry {
                 `Use overwrite: true to replace it.`);
         }
         this.items.set(adapter.id, adapter);
+        this.touch();
         this.notifyListeners();
     }
     /**
@@ -61,6 +77,7 @@ class WorkflowFormatRegistry extends BaseRegistry {
      * @returns Array of NodeMetadata from all format adapters
      */
     getAllFormatNodes() {
+        this.trackVersion(); // reactive dependency (reads items directly)
         const allNodes = [];
         for (const adapter of this.items.values()) {
             if (adapter.nodes && adapter.nodes.length > 0) {
@@ -76,6 +93,7 @@ class WorkflowFormatRegistry extends BaseRegistry {
      * @returns Array of NodeMetadata for the format, or empty array
      */
     getFormatNodes(formatId) {
+        this.trackVersion(); // reactive dependency (reads items directly)
         const adapter = this.items.get(formatId);
         return adapter?.nodes ?? [];
     }
@@ -92,5 +110,3 @@ class WorkflowFormatRegistry extends BaseRegistry {
         }));
     }
 }
-/** Singleton instance of the workflow format registry */
-export const workflowFormatRegistry = new WorkflowFormatRegistry();

package/dist/{schema → schemas}/index.d.ts

@@ -15,9 +15,9 @@
  * const valid = validate(myWorkflow);
  * ```
  *
- * @module schema
+ * @module schemas
  */
-import workflowSchema from '../schemas/v1/workflow.schema.json';
+import workflowSchema from './v1/workflow.schema.json';
 /** Current workflow schema format version */
 export declare const WORKFLOW_SCHEMA_VERSION = "1.0.0";
 export { workflowSchema };

package/dist/{schema → schemas}/index.js

@@ -15,9 +15,9 @@
  * const valid = validate(myWorkflow);
  * ```
  *
- * @module schema
+ * @module schemas
  */
-import workflowSchema from '../schemas/v1/workflow.schema.json';
+import workflowSchema from './v1/workflow.schema.json';
 /** Current workflow schema format version */
 export const WORKFLOW_SCHEMA_VERSION = '1.0.0';
 export { workflowSchema };

package/dist/schemas/v1/workflow.schema.json

@@ -1053,9 +1053,9 @@
     "WorkflowMetadata": {
       "type": "object",
       "properties": {
-        "version": {
+        "schemaVersion": {
           "type": "string",
-          "description": "Workflow version"
+          "description": "Workflow schema format version — identifies the document format, not the workflow's own revision."
         },
         "createdAt": {
           "type": "string",
@@ -1093,7 +1093,7 @@
         }
       },
       "required": [
-        "version",
+        "schemaVersion",
         "createdAt",
         "updatedAt"
       ]

package/dist/services/agentSpecExecutionService.d.ts

@@ -102,5 +102,3 @@ export declare class AgentSpecExecutionService {
     private mapSingleNodeStatus;
     private mapToFlowDropStatus;
 }
-/** Singleton instance */
-export declare const agentSpecExecutionService: AgentSpecExecutionService;

package/dist/services/agentSpecExecutionService.js

@@ -227,7 +227,6 @@ export class AgentSpecExecutionService {
     /** Get the config, throwing if not configured */
     getConfig() {
         this.ensureConfigured();
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return this.config;
     }
     startPolling(executionId, nameToNodeId, onNodeUpdate, onComplete, onError, intervalMs = 2000) {
@@ -333,5 +332,3 @@ export class AgentSpecExecutionService {
         }
     }
 }
-/** Singleton instance */
-export const agentSpecExecutionService = AgentSpecExecutionService.getInstance();

package/dist/services/apiVariableService.d.ts

@@ -6,6 +6,7 @@
  * @module services/apiVariableService
  */
 import type { VariableSchema, ApiVariablesConfig, AuthProvider } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Context for variable API requests
  */
@@ -71,7 +72,7 @@ export declare function resolveEndpointUrl(template: string, context: VariableCo
  * }
  * ```
  */
-export declare function fetchVariableSchema(workflowId: string | undefined, nodeId: string, config: ApiVariablesConfig, authProvider?: AuthProvider): Promise<ApiVariableResult>;
+export declare function fetchVariableSchema(endpointConfig: EndpointConfig | null, workflowId: string | undefined, nodeId: string, config: ApiVariablesConfig, authProvider?: AuthProvider): Promise<ApiVariableResult>;
 /**
  * Clears the variable schema cache.
  * Can optionally clear only entries matching a specific pattern.

package/dist/services/apiVariableService.js

@@ -5,9 +5,8 @@
  *
  * @module services/apiVariableService
  */
-import { getEndpointConfig } from './api.js';
-import { logger } from '../utils/logger.js';
 import { DEFAULT_CACHE_TTL_MS } from '../config/constants.js';
+import { authenticatedFetch } from '../utils/fetchWithAuth.js';
 /**
  * Variable schema cache with TTL support
  * Key format: `variables:{workflowId}:{nodeId}`
@@ -116,7 +115,7 @@ function resolveBodyTemplates(body, context) {
  * }
  * ```
  */
-export async function fetchVariableSchema(workflowId, nodeId, config, authProvider) {
+export async function fetchVariableSchema(endpointConfig, workflowId, nodeId, config, authProvider) {
     const endpoint = config.endpoint;
     const context = { workflowId, nodeId };
     // Generate cache key
@@ -136,48 +135,16 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
     // Resolve the URL with template variables
     let url = resolveEndpointUrl(endpoint.url, context);
     // If URL is relative, prepend base URL from endpoint config
-    if (url.startsWith('/')) {
-        const currentConfig = getEndpointConfig();
-        if (currentConfig?.baseUrl) {
-            const baseUrl = currentConfig.baseUrl.replace(/\/$/, '');
-            url = `${baseUrl}${url}`;
-        }
+    if (url.startsWith('/') && endpointConfig?.baseUrl) {
+        const baseUrl = endpointConfig.baseUrl.replace(/\/$/, '');
+        url = `${baseUrl}${url}`;
     }
     // Prepare request options
     const method = endpoint.method ?? 'GET';
     const timeout = endpoint.timeout ?? 30000;
-    const headers = {
-        Accept: 'application/json',
-        'Content-Type': 'application/json',
-        ...endpoint.headers
-    };
-    // Add auth headers from AuthProvider if available
-    if (authProvider) {
-        try {
-            const authHeaders = await authProvider.getAuthHeaders();
-            Object.assign(headers, authHeaders);
-        }
-        catch (error) {
-            logger.warn('Failed to get auth headers:', error);
-        }
-    }
-    // Add auth headers from endpoint config as fallback
-    const currentConfig = getEndpointConfig();
-    if (currentConfig?.auth) {
-        if (currentConfig.auth.type === 'bearer' && currentConfig.auth.token) {
-            headers['Authorization'] = headers['Authorization'] ?? `Bearer ${currentConfig.auth.token}`;
-        }
-        else if (currentConfig.auth.type === 'api_key' && currentConfig.auth.apiKey) {
-            headers['X-API-Key'] = headers['X-API-Key'] ?? currentConfig.auth.apiKey;
-        }
-        else if (currentConfig.auth.type === 'custom' && currentConfig.auth.headers) {
-            Object.assign(headers, currentConfig.auth.headers);
-        }
-    }
     // Prepare fetch options
     const fetchOptions = {
         method,
-        headers,
         signal: AbortSignal.timeout(timeout)
     };
     // Add body for non-GET requests
@@ -186,7 +153,16 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
         fetchOptions.body = JSON.stringify(resolvedBody);
     }
     try {
-        const response = await fetch(url, fetchOptions);
+        // authenticatedFetch merges auth headers and transparently refreshes +
+        // retries once on 401 via the provider's onUnauthorized hook.
+        const response = await authenticatedFetch(url, fetchOptions, {
+            authProvider,
+            baseHeaders: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                ...endpoint.headers
+            }
+        });
         // Handle 404 as "no variables available"
         if (response.status === 404) {
             return {
@@ -196,15 +172,8 @@ export async function fetchVariableSchema(workflowId, nodeId, config, authProvid
             };
         }
         if (!response.ok) {
-            // Handle authentication errors
+            // Auth errors remain after the provider's refresh attempt.
             if (response.status === 401 || response.status === 403) {
-                if (authProvider?.onUnauthorized) {
-                    const refreshed = await authProvider.onUnauthorized();
-                    if (refreshed) {
-                        // Retry with refreshed auth
-                        return fetchVariableSchema(workflowId, nodeId, config, authProvider);
-                    }
-                }
                 return {
                     success: false,
                     error: 'Authentication failed'