@flowdrop/flowdrop 1.15.0 → 2.0.0-beta.2

package/dist/playground/mount.js

@@ -49,9 +49,8 @@ import PlaygroundModal from '../components/playground/PlaygroundModal.svelte';
 import PlaygroundStudio from '../components/playground/PlaygroundStudio.svelte';
 import PlaygroundApp from '../components/playground/PlaygroundApp.svelte';
 import { initializeSettings } from '../stores/settingsStore.svelte.js';
-import { setEndpointConfig } from '../services/api.js';
 import { playgroundService } from '../services/playgroundService.js';
-import { getCurrentSession, getSessions, getMessages, getIsExecuting, playgroundActions, applyServerResponse, subscribeToSessionStatus } from '../stores/playgroundStore.svelte.js';
+import { createFlowDropInstance, getDefaultInstance } from '../stores/instanceContainer.svelte.js';
 async function resolveEndpointConfig(endpointConfig) {
     if (!endpointConfig)
         return undefined;
@@ -61,7 +60,8 @@ async function resolveEndpointConfig(endpointConfig) {
         ...endpointConfig,
         endpoints: { ...defaultEndpointConfig.endpoints, ...endpointConfig.endpoints }
     };
-    setEndpointConfig(resolved);
+    // The resolved config is passed to the Playground component, which configures
+    // its instance's ApiContext (fd.api) — no module-level state to set here.
     return resolved;
 }
 /**
@@ -86,33 +86,52 @@ function sizeContainer(container, height, width) {
     if (width !== undefined)
         container.style.width = width;
 }
-function buildMountedPlayground(svelteApp, workflowId, config, onSessionStatusChange) {
+/**
+ * Resolve the FlowDrop instance for a playground mount. No `instanceId` →
+ * the page-default instance (legacy shared-store behavior); an explicit id →
+ * a fresh isolated instance owned (and destroyed) by this mount.
+ */
+function acquirePlaygroundInstance(instanceId) {
+    if (instanceId) {
+        return { fd: createFlowDropInstance({ id: instanceId }), ownsInstance: true };
+    }
+    return { fd: getDefaultInstance(), ownsInstance: false };
+}
+function buildMountedPlayground(svelteApp, workflowId, config, fd, ownsInstance, onSessionStatusChange) {
     const pollingInterval = config.pollingInterval ?? 1500;
     const unsubscribeStatus = onSessionStatusChange
-        ? subscribeToSessionStatus(onSessionStatusChange)
+        ? fd.playground.subscribeToSessionStatus(onSessionStatusChange)
         : undefined;
     return {
         destroy: () => {
             unsubscribeStatus?.();
+            // Caution (shared default instance): stopPolling is page-global and
+            // reset() clears state other default-mounted playgrounds rely on —
+            // pass `instanceId` to isolate. Preserved legacy behavior.
             playgroundService.stopPolling();
-            playgroundActions.reset();
+            fd.playground.reset();
+            // Fully dispose instances created for this mount; the shared default
+            // instance only gets the reset above (legacy behavior).
+            if (ownsInstance) {
+                fd.destroy();
+            }
             unmount(svelteApp);
         },
-        getCurrentSession: () => getCurrentSession(),
-        getSessions: () => getSessions(),
-        getMessageCount: () => getMessages().length,
-        isExecuting: () => getIsExecuting(),
+        getCurrentSession: () => fd.playground.currentSession,
+        getSessions: () => fd.playground.sessions,
+        getMessageCount: () => fd.playground.messageCount,
+        isExecuting: () => fd.playground.isExecuting,
         stopPolling: () => playgroundService.stopPolling(),
         startPolling: () => {
-            const session = getCurrentSession();
+            const session = fd.playground.currentSession;
             if (session) {
-                playgroundService.startPolling(session.id, (response) => applyServerResponse(response, session.id), pollingInterval, config.shouldStopPolling, playgroundService.getLastSequenceNumber());
+                playgroundService.startPolling(fd.api.config, session.id, (response) => fd.playground.applyServerResponse(response, session.id), pollingInterval, config.shouldStopPolling, playgroundService.getLastSequenceNumber(), fd.api.authProvider);
             }
         },
-        pushMessages: (response) => applyServerResponse(response, null),
+        pushMessages: (response) => fd.playground.applyServerResponse(response, null),
         reset: () => {
             playgroundService.stopPolling();
-            playgroundActions.reset();
+            fd.playground.reset();
         }
     };
 }
@@ -146,7 +165,7 @@ function buildMountedPlayground(svelteApp, workflowId, config, onSessionStatusCh
  * ```
  */
 export async function mountPlayground(container, options) {
-    const { workflowId, workflow, mode = 'standalone', initialSessionId, endpointConfig, config = {}, height, width, settings: initialSettings, onClose, onSessionStatusChange } = options;
+    const { workflowId, workflow, mode = 'standalone', initialSessionId, endpointConfig, authProvider, config = {}, height, width, settings: initialSettings, onClose, onSessionStatusChange, instanceId } = options;
     // Validate required parameters
     if (!workflowId) {
         throw new Error('workflowId is required for mountPlayground()');
@@ -162,6 +181,7 @@ export async function mountPlayground(container, options) {
         endpointConfig,
         settings: initialSettings
     });
+    const { fd, ownsInstance } = acquirePlaygroundInstance(instanceId);
     let targetContainer = container;
     if (mode === 'modal') {
         targetContainer = document.body;
@@ -175,10 +195,12 @@ export async function mountPlayground(container, options) {
             target: targetContainer,
             props: {
                 isOpen: true,
+                instance: fd,
                 workflowId,
                 workflow,
                 initialSessionId,
                 endpointConfig: finalEndpointConfig,
+                authProvider,
                 config,
                 onClose: () => {
                     if (onClose) {
@@ -192,17 +214,19 @@ export async function mountPlayground(container, options) {
         svelteApp = mount(Playground, {
             target: targetContainer,
             props: {
+                instance: fd,
                 workflowId,
                 workflow,
                 mode,
                 initialSessionId,
                 endpointConfig: finalEndpointConfig,
+                authProvider,
                 config,
                 onClose
             }
         });
     }
-    return buildMountedPlayground(svelteApp, workflowId, config, onSessionStatusChange);
+    return buildMountedPlayground(svelteApp, workflowId, config, fd, ownsInstance, onSessionStatusChange);
 }
 /**
  * Unmount a Playground instance
@@ -225,7 +249,7 @@ export function unmountPlayground(app) {
     }
 }
 export async function mountPlaygroundStudio(container, options) {
-    const { workflowId, workflow, mode = 'standalone', initialSessionId, endpointConfig, config = {}, height, width, initialPipelineOpen, minChatWidth, initialPipelineWidth, settings: initialSettings, onClose, onSessionNavigate, onSessionStatusChange, pipelineViews } = options;
+    const { workflowId, workflow, mode = 'standalone', initialSessionId, endpointConfig, authProvider, config = {}, height, width, initialPipelineOpen, minChatWidth, initialPipelineWidth, settings: initialSettings, onClose, onSessionNavigate, onSessionStatusChange, pipelineViews, instanceId } = options;
     if (!workflowId) {
         throw new Error('workflowId is required for mountPlaygroundStudio()');
     }
@@ -239,15 +263,18 @@ export async function mountPlaygroundStudio(container, options) {
         endpointConfig,
         settings: initialSettings
     });
+    const { fd, ownsInstance } = acquirePlaygroundInstance(instanceId);
     sizeContainer(container, height, width);
     const svelteApp = mount(PlaygroundStudio, {
         target: container,
         props: {
+            instance: fd,
             workflowId,
             workflow,
             mode,
             initialSessionId,
             endpointConfig: finalEndpointConfig,
+            authProvider,
             config,
             onClose,
             onSessionNavigate,
@@ -257,7 +284,7 @@ export async function mountPlaygroundStudio(container, options) {
             extraPipelineViews: pipelineViews
         }
     });
-    return buildMountedPlayground(svelteApp, workflowId, config, onSessionStatusChange);
+    return buildMountedPlayground(svelteApp, workflowId, config, fd, ownsInstance, onSessionStatusChange);
 }
 /**
  * Mount the full-page PlaygroundApp (Navbar + PlaygroundStudio) into a container.
@@ -280,7 +307,7 @@ export async function mountPlaygroundStudio(container, options) {
  * ```
  */
 export async function mountPlaygroundApp(container, options) {
-    const { workflowId, workflow, mode = 'standalone', initialSessionId, endpointConfig, config = {}, height, width, showNavbar = true, navbarTitle, primaryActions, showSettings = true, settingsCategories, showSettingsSyncButton, showSettingsResetButton, initialPipelineOpen, minChatWidth, initialPipelineWidth, settings: initialSettings, onClose, onSessionNavigate, onSessionStatusChange } = options;
+    const { workflowId, workflow, mode = 'standalone', initialSessionId, endpointConfig, authProvider, config = {}, height, width, showNavbar = true, navbarTitle, primaryActions, showSettings = true, settingsCategories, showSettingsSyncButton, showSettingsResetButton, initialPipelineOpen, minChatWidth, initialPipelineWidth, settings: initialSettings, onClose, onSessionNavigate, onSessionStatusChange, instanceId } = options;
     if (!workflowId) {
         throw new Error('workflowId is required for mountPlaygroundApp()');
     }
@@ -297,15 +324,18 @@ export async function mountPlaygroundApp(container, options) {
         endpointConfig,
         settings: initialSettings
     });
+    const { fd, ownsInstance } = acquirePlaygroundInstance(instanceId);
     sizeContainer(container, height, width);
     const svelteApp = mount(PlaygroundApp, {
         target: container,
         props: {
+            instance: fd,
             workflowId,
             workflow,
             mode,
             initialSessionId,
             endpointConfig: finalEndpointConfig,
+            authProvider,
             config,
             showNavbar,
             navbarTitle,
@@ -321,5 +351,5 @@ export async function mountPlaygroundApp(container, options) {
             onSessionNavigate
         }
     });
-    return buildMountedPlayground(svelteApp, workflowId, config, onSessionStatusChange);
+    return buildMountedPlayground(svelteApp, workflowId, config, fd, ownsInstance, onSessionStatusChange);
 }

package/dist/registry/{BaseRegistry.d.ts → BaseRegistry.svelte.d.ts}

@@ -5,7 +5,15 @@
  * mechanics: Map storage, subscribe/notify, onClear callbacks, and size tracking.
  *
  * Subclasses define their own `register()` method with domain-appropriate
- * signatures, using `this.items` and `this.notifyListeners()` directly.
+ * signatures, using `this.items`, `this.touch()`, and `this.notifyListeners()`.
+ *
+ * Reactivity: a `.svelte.ts` module so it can hold a `$state` version counter
+ * (`#version`). Every mutating path bumps it via `touch()`; every read method
+ * components derive from reads it once at the top. This makes the plain `Map`
+ * backing store observable to `$derived`/`$effect`, so registrations made
+ * AFTER a component mounts (e.g. `fd.nodes.registerCustom(...)`) invalidate the
+ * derived and trigger a re-render. Mirrors WorkflowStore's `#editVersion`
+ * monotonic-counter precedent (workflowStore.svelte.ts).
  *
  * @example
  * ```typescript
@@ -15,18 +23,31 @@
  *       throw new Error(`Already registered: ${item.id}`);
  *     }
  *     this.items.set(item.id, item);
+ *     this.touch();
  *     this.notifyListeners();
  *   }
  * }
  * ```
  */
 export declare class BaseRegistry<K, V> {
+    #private;
     /** Internal storage map */
     protected items: Map<K, V>;
     /** Change listeners */
     private listeners;
     /** Callbacks invoked when the registry is cleared (for resetting flags) */
     private clearCallbacks;
+    /**
+     * Bump the reactive version counter. Subclasses MUST call this after any
+     * mutation of `this.items` so derived reads invalidate.
+     */
+    protected touch(): void;
+    /**
+     * Read the reactive version counter. Subclasses that read `this.items`
+     * directly (instead of via `get`/`getAll`/etc.) MUST call this so the access
+     * is tracked as a reactive dependency.
+     */
+    protected trackVersion(): void;
     /**
      * Unregister an item by key.
      *

package/dist/registry/{BaseRegistry.js → BaseRegistry.svelte.js}

@@ -5,7 +5,15 @@
  * mechanics: Map storage, subscribe/notify, onClear callbacks, and size tracking.
  *
  * Subclasses define their own `register()` method with domain-appropriate
- * signatures, using `this.items` and `this.notifyListeners()` directly.
+ * signatures, using `this.items`, `this.touch()`, and `this.notifyListeners()`.
+ *
+ * Reactivity: a `.svelte.ts` module so it can hold a `$state` version counter
+ * (`#version`). Every mutating path bumps it via `touch()`; every read method
+ * components derive from reads it once at the top. This makes the plain `Map`
+ * backing store observable to `$derived`/`$effect`, so registrations made
+ * AFTER a component mounts (e.g. `fd.nodes.registerCustom(...)`) invalidate the
+ * derived and trigger a re-render. Mirrors WorkflowStore's `#editVersion`
+ * monotonic-counter precedent (workflowStore.svelte.ts).
  *
  * @example
  * ```typescript
@@ -15,6 +23,7 @@
  *       throw new Error(`Already registered: ${item.id}`);
  *     }
  *     this.items.set(item.id, item);
+ *     this.touch();
  *     this.notifyListeners();
  *   }
  * }
@@ -23,10 +32,30 @@
 export class BaseRegistry {
     /** Internal storage map */
     items = new Map();
+    /**
+     * Reactive version counter. Bumped by `touch()` on every mutation; read by
+     * every observable read method so Svelte tracks the plain Map as a dependency.
+     */
+    #version = $state(0);
     /** Change listeners */
     listeners = new Set();
     /** Callbacks invoked when the registry is cleared (for resetting flags) */
     clearCallbacks = new Set();
+    /**
+     * Bump the reactive version counter. Subclasses MUST call this after any
+     * mutation of `this.items` so derived reads invalidate.
+     */
+    touch() {
+        this.#version++;
+    }
+    /**
+     * Read the reactive version counter. Subclasses that read `this.items`
+     * directly (instead of via `get`/`getAll`/etc.) MUST call this so the access
+     * is tracked as a reactive dependency.
+     */
+    trackVersion() {
+        void this.#version; // reactive dependency
+    }
     /**
      * Unregister an item by key.
      *
@@ -36,6 +65,7 @@ export class BaseRegistry {
     unregister(key) {
         const result = this.items.delete(key);
         if (result) {
+            this.touch();
             this.notifyListeners();
         }
         return result;
@@ -47,6 +77,7 @@ export class BaseRegistry {
      * @returns The item if found, undefined otherwise
      */
     get(key) {
+        this.trackVersion(); // reactive dependency
         return this.items.get(key);
     }
     /**
@@ -56,6 +87,7 @@ export class BaseRegistry {
      * @returns true if the key is registered
      */
     has(key) {
+        this.trackVersion(); // reactive dependency
         return this.items.has(key);
     }
     /**
@@ -64,6 +96,7 @@ export class BaseRegistry {
      * @returns Array of registered keys
      */
     getKeys() {
+        this.trackVersion(); // reactive dependency
         return Array.from(this.items.keys());
     }
     /**
@@ -72,6 +105,7 @@ export class BaseRegistry {
      * @returns Array of all registered items
      */
     getAll() {
+        this.trackVersion(); // reactive dependency
         return Array.from(this.items.values());
     }
     /**
@@ -102,6 +136,7 @@ export class BaseRegistry {
      */
     clear() {
         this.items.clear();
+        this.touch();
         for (const cb of this.clearCallbacks) {
             cb();
         }
@@ -111,6 +146,7 @@ export class BaseRegistry {
      * Get the count of registered items.
      */
     get size() {
+        this.trackVersion(); // reactive dependency
         return this.items.size;
     }
     /**

package/dist/registry/builtinFormats.d.ts

@@ -1,23 +1,14 @@
 /**
- * Built-in Workflow Format Registration
+ * Built-in Workflow Format Adapters
  *
- * Registers the default FlowDrop and Agent Spec format adapters
- * with the workflow format registry.
- *
- * This module is automatically loaded when imported,
- * ensuring built-in formats are available without user action.
- */
-/**
- * Register all built-in workflow format adapters.
- * Safe to call multiple times — will only register once.
+ * Provides the default FlowDrop and Agent Spec format adapters. These are used
+ * to seed each instance's `WorkflowFormatRegistry` (see `instanceContainer`).
  */
-export declare function registerBuiltinFormats(): void;
+import type { WorkflowFormatAdapter } from './workflowFormatRegistry.js';
 /**
- * Check if built-in formats have been registered.
- */
-export declare function areBuiltinFormatsRegistered(): boolean;
-/**
- * Reset the registration state.
- * Primarily useful for testing.
+ * Build the built-in workflow format adapters (FlowDrop native + Agent Spec).
+ *
+ * Returns a fresh array on each call so every instance owns independent
+ * adapter objects (the Agent Spec adapter holds per-conversion state).
  */
-export declare function resetBuiltinFormatRegistration(): void;
+export declare function getBuiltinFormatAdapters(): WorkflowFormatAdapter[];

package/dist/registry/builtinFormats.js

@@ -1,27 +1,18 @@
 /**
- * Built-in Workflow Format Registration
+ * Built-in Workflow Format Adapters
  *
- * Registers the default FlowDrop and Agent Spec format adapters
- * with the workflow format registry.
- *
- * This module is automatically loaded when imported,
- * ensuring built-in formats are available without user action.
+ * Provides the default FlowDrop and Agent Spec format adapters. These are used
+ * to seed each instance's `WorkflowFormatRegistry` (see `instanceContainer`).
  */
-import { workflowFormatRegistry } from './workflowFormatRegistry.js';
 import { AgentSpecAdapter } from '../adapters/agentspec/AgentSpecAdapter.js';
 import { validateForAgentSpecExport } from '../adapters/agentspec/validator.js';
 /**
- * Track whether built-in formats have been registered.
- * Prevents duplicate registration on hot reload.
- */
-let registered = false;
-/**
- * Register all built-in workflow format adapters.
- * Safe to call multiple times — will only register once.
+ * Build the built-in workflow format adapters (FlowDrop native + Agent Spec).
+ *
+ * Returns a fresh array on each call so every instance owns independent
+ * adapter objects (the Agent Spec adapter holds per-conversion state).
  */
-export function registerBuiltinFormats() {
-    if (registered)
-        return;
+export function getBuiltinFormatAdapters() {
     // FlowDrop native — passthrough (StandardWorkflow ↔ JSON)
     const flowdropAdapter = {
         id: 'flowdrop',
@@ -32,7 +23,6 @@ export function registerBuiltinFormats() {
         export: (workflow) => JSON.stringify(workflow, null, 2),
         import: (data) => JSON.parse(data)
     };
-    workflowFormatRegistry.register(flowdropAdapter);
     // Agent Spec — wraps existing AgentSpecAdapter
     // No bundled nodes — Agent Spec node types are user-provided via
     // getDefaultAgentSpecNodeTypes() or custom definitions passed to mountFlowDropApp()
@@ -46,25 +36,5 @@ export function registerBuiltinFormats() {
         import: (data) => agentSpecAdapter.importJSON(data),
         validate: (workflow) => validateForAgentSpecExport(workflow)
     };
-    workflowFormatRegistry.register(agentSpecFormatAdapter);
-    registered = true;
-}
-/**
- * Check if built-in formats have been registered.
- */
-export function areBuiltinFormatsRegistered() {
-    return registered;
-}
-/**
- * Reset the registration state.
- * Primarily useful for testing.
- */
-export function resetBuiltinFormatRegistration() {
-    registered = false;
+    return [flowdropAdapter, agentSpecFormatAdapter];
 }
-// Sync registration flag with registry.clear() for test isolation
-workflowFormatRegistry.onClear(() => {
-    registered = false;
-});
-// Auto-register built-in formats when this module is imported
-registerBuiltinFormats();

package/dist/registry/builtinNodeTypes.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Built-in Node Type Metadata (pure — no component imports)
+ *
+ * The type identifiers, aliases, and resolution helpers for FlowDrop's built-in
+ * node types, with ZERO dependency on the Svelte node components. Utilities that
+ * only need to reason about type strings (e.g. `utils/nodeTypes.ts`, reachable
+ * from `@flowdrop/flowdrop/core`) import from here, so the lightweight `core`
+ * entry never statically pulls in node components, marked, or DOMPurify.
+ *
+ * The component registrations themselves live in `./builtinNodes.ts`, which
+ * re-exports everything here for backward compatibility.
+ *
+ * @module registry/builtinNodeTypes
+ */
+/**
+ * Source identifier for built-in FlowDrop components.
+ */
+export declare const FLOWDROP_SOURCE = "flowdrop";
+/**
+ * Type for built-in node types.
+ * Use this when you specifically need a built-in type.
+ */
+export type BuiltinNodeType = 'workflowNode' | 'simple' | 'square' | 'atom' | 'tool' | 'gateway' | 'note' | 'terminal' | 'idea';
+/**
+ * Array of built-in type strings for runtime validation.
+ */
+export declare const BUILTIN_NODE_TYPES: BuiltinNodeType[];
+/**
+ * Alias mapping for type resolution.
+ * Maps alternative type names to their canonical registration.
+ */
+export declare const BUILTIN_TYPE_ALIASES: Record<string, string>;
+/**
+ * Get the canonical type for a given type string.
+ * Handles aliases like "default" -> "workflowNode".
+ *
+ * @param type - The type string to resolve
+ * @returns The canonical type string
+ */
+export declare function resolveBuiltinAlias(type: string): string;
+/**
+ * Check if a type is a built-in FlowDrop type.
+ *
+ * @param type - The type to check
+ * @returns true if this is a built-in type
+ */
+export declare function isBuiltinType(type: string): boolean;
+/**
+ * Get all built-in type identifiers.
+ *
+ * @returns Array of built-in type strings
+ */
+export declare function getBuiltinTypes(): string[];

package/dist/registry/builtinNodeTypes.js

@@ -0,0 +1,67 @@
+/**
+ * Built-in Node Type Metadata (pure — no component imports)
+ *
+ * The type identifiers, aliases, and resolution helpers for FlowDrop's built-in
+ * node types, with ZERO dependency on the Svelte node components. Utilities that
+ * only need to reason about type strings (e.g. `utils/nodeTypes.ts`, reachable
+ * from `@flowdrop/flowdrop/core`) import from here, so the lightweight `core`
+ * entry never statically pulls in node components, marked, or DOMPurify.
+ *
+ * The component registrations themselves live in `./builtinNodes.ts`, which
+ * re-exports everything here for backward compatibility.
+ *
+ * @module registry/builtinNodeTypes
+ */
+/**
+ * Source identifier for built-in FlowDrop components.
+ */
+export const FLOWDROP_SOURCE = 'flowdrop';
+/**
+ * Array of built-in type strings for runtime validation.
+ */
+export const BUILTIN_NODE_TYPES = [
+    'workflowNode',
+    'simple',
+    'square',
+    'atom',
+    'tool',
+    'gateway',
+    'note',
+    'terminal',
+    'idea'
+];
+/**
+ * Alias mapping for type resolution.
+ * Maps alternative type names to their canonical registration.
+ */
+export const BUILTIN_TYPE_ALIASES = {
+    default: 'workflowNode'
+};
+/**
+ * Get the canonical type for a given type string.
+ * Handles aliases like "default" -> "workflowNode".
+ *
+ * @param type - The type string to resolve
+ * @returns The canonical type string
+ */
+export function resolveBuiltinAlias(type) {
+    return BUILTIN_TYPE_ALIASES[type] ?? type;
+}
+/**
+ * Check if a type is a built-in FlowDrop type.
+ *
+ * @param type - The type to check
+ * @returns true if this is a built-in type
+ */
+export function isBuiltinType(type) {
+    const canonicalType = resolveBuiltinAlias(type);
+    return BUILTIN_NODE_TYPES.includes(canonicalType);
+}
+/**
+ * Get all built-in type identifiers.
+ *
+ * @returns Array of built-in type strings
+ */
+export function getBuiltinTypes() {
+    return [...BUILTIN_NODE_TYPES];
+}

package/dist/registry/builtinNodes.d.ts

@@ -6,72 +6,10 @@
  * ensuring all built-in node types are available without user action.
  */
 import { type NodeComponentRegistration } from './nodeComponentRegistry.js';
-/**
- * Source identifier for built-in FlowDrop components
- */
-export declare const FLOWDROP_SOURCE = "flowdrop";
+export { FLOWDROP_SOURCE, BUILTIN_TYPE_ALIASES, BUILTIN_NODE_TYPES, resolveBuiltinAlias, isBuiltinType, getBuiltinTypes } from './builtinNodeTypes.js';
+export type { BuiltinNodeType } from './builtinNodeTypes.js';
 /**
  * Built-in FlowDrop node component registrations.
  * These are the default node types that ship with FlowDrop.
  */
 export declare const BUILTIN_NODE_COMPONENTS: NodeComponentRegistration[];
-/**
- * Alias mapping for type resolution.
- * Maps alternative type names to their canonical registration.
- */
-export declare const BUILTIN_TYPE_ALIASES: Record<string, string>;
-/**
- * Initialize the registry with built-in components.
- * This is called automatically when the library loads.
- *
- * Safe to call multiple times - will only register once.
- *
- * @example
- * ```typescript
- * // Usually not needed - called automatically
- * // But can be called manually if needed
- * registerBuiltinNodes();
- * ```
- */
-export declare function registerBuiltinNodes(): void;
-/**
- * Check if built-in nodes have been registered.
- *
- * @returns true if registerBuiltinNodes() has been called
- */
-export declare function areBuiltinsRegistered(): boolean;
-/**
- * Reset the registration state.
- * Primarily useful for testing.
- */
-export declare function resetBuiltinRegistration(): void;
-/**
- * Get the canonical type for a given type string.
- * Handles aliases like "default" -> "workflowNode".
- *
- * @param type - The type string to resolve
- * @returns The canonical type string
- */
-export declare function resolveBuiltinAlias(type: string): string;
-/**
- * Check if a type is a built-in FlowDrop type.
- *
- * @param type - The type to check
- * @returns true if this is a built-in type
- */
-export declare function isBuiltinType(type: string): boolean;
-/**
- * Get all built-in type identifiers.
- *
- * @returns Array of built-in type strings
- */
-export declare function getBuiltinTypes(): string[];
-/**
- * Type for built-in node types.
- * Use this when you specifically need a built-in type.
- */
-export type BuiltinNodeType = 'workflowNode' | 'simple' | 'square' | 'atom' | 'tool' | 'gateway' | 'note' | 'terminal' | 'idea';
-/**
- * Array of built-in type strings for runtime validation.
- */
-export declare const BUILTIN_NODE_TYPES: BuiltinNodeType[];