@d34dman/flowdrop 0.0.60 → 0.0.62

package/dist/types/index.d.ts

@@ -1158,6 +1158,8 @@ export interface NodeExecutionInfo {
     lastError?: string;
     /** Whether the node is currently being executed */
     isExecuting: boolean;
+    /** Execution output data (e.g., active branches for gateway nodes) */
+    output?: Record<string, unknown>;
 }
 /**
  * Workflow execution status

package/dist/types/interrupt.d.ts

@@ -17,7 +17,7 @@ export { initialState, transition, isTerminalState, isSubmitting, hasError, canS
  * - `text`: Free-form text input
  * - `form`: JSON Schema-based form
  */
-export type InterruptType = 'confirmation' | 'choice' | 'text' | 'form';
+export type InterruptType = 'confirmation' | 'choice' | 'text' | 'form' | 'review';
 /**
  * Status of an interrupt request
  *
@@ -101,10 +101,86 @@ export interface FormConfig {
     /** Default values for form fields */
     defaultValues?: Record<string, unknown>;
 }
+/**
+ * A single field change proposed for review
+ *
+ * @example
+ * ```typescript
+ * const change: ReviewChange = {
+ *   field: "title",
+ *   label: "Page Title",
+ *   original: "About Us",
+ *   proposed: "About Our Company"
+ * };
+ * ```
+ */
+export interface ReviewChange {
+    /** Field identifier (machine key) */
+    field: string;
+    /** Human-readable field label */
+    label: string;
+    /** Original value before the proposed change */
+    original: unknown;
+    /** Proposed new value */
+    proposed: unknown;
+}
+/**
+ * Configuration for review-type interrupts
+ *
+ * Displays a list of proposed field changes for the user to
+ * accept or reject individually before submitting.
+ */
+export interface ReviewConfig {
+    /** The prompt message to display */
+    message: string;
+    /** List of field changes to review */
+    changes: ReviewChange[];
+    /** Label for the "Accept All" button */
+    acceptAllLabel?: string;
+    /** Label for the "Reject All" button */
+    rejectAllLabel?: string;
+    /** Label for the submit button */
+    submitLabel?: string;
+}
+/**
+ * Per-field decision in a review resolution
+ */
+export interface ReviewFieldDecision {
+    /** Whether the proposed change was accepted */
+    accepted: boolean;
+    /** The effective value (proposed if accepted, original if rejected) */
+    value: unknown;
+}
+/**
+ * Resolution value for review-type interrupts
+ *
+ * Contains individual decisions for each field and a summary count.
+ *
+ * @example
+ * ```typescript
+ * const resolution: ReviewResolution = {
+ *   decisions: {
+ *     title: { accepted: true, value: "About Our Company" },
+ *     meta_description: { accepted: false, value: "Learn about us" }
+ *   },
+ *   summary: { accepted: 1, rejected: 1, total: 2 }
+ * };
+ * ```
+ */
+export interface ReviewResolution {
+    /** Map of field identifier to the user's decision */
+    decisions: Record<string, ReviewFieldDecision>;
+    /** Summary counts of accepted/rejected fields */
+    summary: {
+        accepted: number;
+        rejected: number;
+        total: number;
+    };
+}
 /**
  * Union type for interrupt-specific configuration
  */
-export type InterruptConfig = ConfirmationConfig | ChoiceConfig | TextConfig | FormConfig;
+export type InterruptConfig = ConfirmationConfig | ChoiceConfig | TextConfig | FormConfig | ReviewConfig;
 /**
  * Core interrupt data structure
  *
@@ -268,6 +344,14 @@ export interface InterruptMessageMetadata {
     resolvedByUserName?: string;
     /** User ID of the person who resolved the interrupt */
     resolvedByUserId?: string;
+    /** Review: list of field changes to review */
+    changes?: ReviewChange[];
+    /** Review: label for the "Accept All" button */
+    accept_all_label?: string;
+    /** Review: label for the "Reject All" button */
+    reject_all_label?: string;
+    /** Review: label for the submit button */
+    submit_label?: string;
 }
 /**
  * Type guard to check if message metadata indicates an interrupt
@@ -275,7 +359,7 @@ export interface InterruptMessageMetadata {
  * @param metadata - Message metadata to check
  * @returns True if the metadata indicates an interrupt request
  */
-export declare function isInterruptMetadata(metadata: Record<string, unknown> | undefined): boolean;
+export declare function isInterruptMetadata(metadata: Record<string, unknown> | undefined): metadata is Record<string, unknown>;
 /**
  * Safely extract interrupt metadata from a generic record
  *
@@ -299,9 +383,9 @@ export interface InterruptPollingConfig {
     /** Whether to enable dedicated interrupt polling */
     enabled: boolean;
     /** Polling interval in milliseconds */
-    interval?: number;
+    interval: number;
     /** Maximum polling backoff interval in milliseconds */
-    maxBackoff?: number;
+    maxBackoff: number;
 }
 /**
  * Default interrupt polling configuration

package/dist/types/interrupt.js

@@ -50,7 +50,11 @@ export function extractInterruptMetadata(metadata) {
         min_selections: metadata.min_selections,
         max_selections: metadata.max_selections,
         resolvedByUserName: metadata.resolvedByUserName,
-        resolvedByUserId: metadata.resolvedByUserId
+        resolvedByUserId: metadata.resolvedByUserId,
+        changes: metadata.changes,
+        accept_all_label: metadata.accept_all_label,
+        reject_all_label: metadata.reject_all_label,
+        submit_label: metadata.submit_label
     };
 }
 /**
@@ -119,6 +123,14 @@ function buildInterruptConfig(metadata, message) {
                 schema: metadata.schema ?? { type: 'object', properties: {} },
                 defaultValues: metadata.default_value
             };
+        case 'review':
+            return {
+                message,
+                changes: metadata.changes ?? [],
+                acceptAllLabel: metadata.accept_all_label,
+                rejectAllLabel: metadata.reject_all_label,
+                submitLabel: metadata.submit_label
+            };
         default:
             return { message };
     }

package/dist/types/playground.d.ts

@@ -10,7 +10,31 @@ import type { ConfigProperty } from './index.js';
 /**
  * Status of a playground session
  */
-export type PlaygroundSessionStatus = 'idle' | 'running' | 'completed' | 'failed';
+export type PlaygroundSessionStatus = 'idle' | 'running' | 'awaiting_input' | 'completed' | 'failed';
+/**
+ * Statuses that stop polling by default (resource efficiency)
+ */
+export declare const DEFAULT_STOP_POLLING_STATUSES: PlaygroundSessionStatus[];
+/**
+ * Statuses that are considered terminal by default (clears isExecuting)
+ */
+export declare const DEFAULT_TERMINAL_STATUSES: PlaygroundSessionStatus[];
+/**
+ * Default implementation for determining if polling should stop.
+ * Consumers can override this via PlaygroundConfig.shouldStopPolling.
+ *
+ * @param status - The current session status
+ * @returns True if polling should stop
+ */
+export declare function defaultShouldStopPolling(status: PlaygroundSessionStatus): boolean;
+/**
+ * Default implementation for determining if a status is terminal (clears isExecuting).
+ * Consumers can override this via PlaygroundConfig.isTerminalStatus.
+ *
+ * @param status - The current session status
+ * @returns True if the status is terminal
+ */
+export declare function defaultIsTerminalStatus(status: PlaygroundSessionStatus): boolean;
 /**
  * Role of a message sender in the playground
  *
@@ -219,6 +243,11 @@ export interface PlaygroundConfig {
      * Note: Only runs once per session - subsequent runs require clicking the Run button.
      */
     autoRun?: boolean;
+    /**
+     * Width of the sidebar in CSS units (default: "280px")
+     * Accepts any valid CSS width value, e.g. "300px", "20rem".
+     */
+    sidebarWidth?: string;
     /**
      * Whether to show the sidebar with session list (default: true)
      * When false, the sidebar is hidden, creating a minimal chat widget experience.
@@ -231,6 +260,18 @@ export interface PlaygroundConfig {
      * Typically used together with showSidebar: false for minimal UI.
      */
     showSessionHeader?: boolean;
+    /**
+     * Determines if polling should stop for a given session status.
+     * Override to customize which statuses pause polling.
+     * @default defaultShouldStopPolling (stops on idle, completed, failed, awaiting_input)
+     */
+    shouldStopPolling?: (status: PlaygroundSessionStatus) => boolean;
+    /**
+     * Determines if a session status is terminal (clears isExecuting).
+     * Override to customize which statuses end the executing state.
+     * @default defaultIsTerminalStatus (terminal on idle, completed, failed, awaiting_input)
+     */
+    isTerminalStatus?: (status: PlaygroundSessionStatus) => boolean;
 }
 /**
  * Metadata field to control Run button state from backend.

package/dist/types/playground.js

@@ -6,6 +6,44 @@
  *
  * @module types/playground
  */
+/**
+ * Statuses that stop polling by default (resource efficiency)
+ */
+export const DEFAULT_STOP_POLLING_STATUSES = [
+    'idle',
+    'completed',
+    'failed',
+    'awaiting_input'
+];
+/**
+ * Statuses that are considered terminal by default (clears isExecuting)
+ */
+export const DEFAULT_TERMINAL_STATUSES = [
+    'idle',
+    'completed',
+    'failed',
+    'awaiting_input'
+];
+/**
+ * Default implementation for determining if polling should stop.
+ * Consumers can override this via PlaygroundConfig.shouldStopPolling.
+ *
+ * @param status - The current session status
+ * @returns True if polling should stop
+ */
+export function defaultShouldStopPolling(status) {
+    return DEFAULT_STOP_POLLING_STATUSES.includes(status);
+}
+/**
+ * Default implementation for determining if a status is terminal (clears isExecuting).
+ * Consumers can override this via PlaygroundConfig.isTerminalStatus.
+ *
+ * @param status - The current session status
+ * @returns True if the status is terminal
+ */
+export function defaultIsTerminalStatus(status) {
+    return DEFAULT_TERMINAL_STATUSES.includes(status);
+}
 /**
  * Metadata field to control Run button state from backend.
  * When a message contains this field set to true, the Run button becomes enabled.

package/dist/types/settings.js

@@ -66,7 +66,7 @@ export const DEFAULT_UI_SETTINGS = {
 export const DEFAULT_BEHAVIOR_SETTINGS = {
     autoSave: false,
     autoSaveInterval: 30000,
-    undoHistoryLimit: 0,
+    undoHistoryLimit: 50,
     confirmDelete: false
 };
 /**

package/dist/utils/colors.js

@@ -4,7 +4,8 @@
  * Uses BEM syntax for CSS classes
  */
 import { getPortCompatibilityChecker } from './connections.js';
-import { getCategoryColor as getCategoryColorFromStore } from '../stores/categoriesStore.js';
+import { getCategoryColor as getCategoryColorFromStore } from '../stores/categoriesStore.svelte.js';
+import { logger } from './logger.js';
 /**
  * Category color mapping to design tokens (CSS variables)
  * Uses --fd-node-* tokens from tokens.css
@@ -83,7 +84,6 @@ export function getDataTypeColorToken(dataType) {
     }
     catch {
         // Fallback to static color mapping if port checker not initialized
-        // console.warn("Port compatibility checker not initialized, using fallback colors");
     }
     return DEFAULT_DATA_TYPE_COLORS[dataType.toLowerCase()] || 'var(--fd-node-slate)';
 }
@@ -96,7 +96,7 @@ export function getDataTypeConfig(dataType) {
         return checker.getDataTypeConfig(dataType);
     }
     catch (error) {
-        console.warn('Port compatibility checker not initialized:', error);
+        logger.warn('Port compatibility checker not initialized:', error);
         return undefined;
     }
 }
@@ -109,7 +109,7 @@ export function getAvailableDataTypes() {
         return checker.getEnabledDataTypes();
     }
     catch (error) {
-        console.warn('Port compatibility checker not initialized:', error);
+        logger.warn('Port compatibility checker not initialized:', error);
         return [];
     }
 }

package/dist/utils/connections.js

@@ -266,6 +266,18 @@ export function getConnectionSuggestions(nodeId, nodes, nodeTypes) {
  * @returns True if any cycle exists in the workflow
  */
 export function hasCycles(nodes, edges) {
+    // Build adjacency map once (O(E)) so the DFS inner loop is O(1) per lookup
+    // instead of scanning all edges on every recursive call (which was O(V*E)).
+    const adjacencyMap = new Map();
+    for (const node of nodes) {
+        adjacencyMap.set(node.id, []);
+    }
+    for (const edge of edges) {
+        const neighbors = adjacencyMap.get(edge.source);
+        if (neighbors) {
+            neighbors.push(edge.target);
+        }
+    }
     const visited = new Set();
     const recursionStack = new Set();
     function hasCycleUtil(nodeId) {
@@ -275,10 +287,10 @@ export function hasCycles(nodes, edges) {
             return false;
         visited.add(nodeId);
         recursionStack.add(nodeId);
-        // Get all outgoing edges from this node
-        const outgoingEdges = edges.filter((e) => e.source === nodeId);
-        for (const edge of outgoingEdges) {
-            if (hasCycleUtil(edge.target))
+        // Use pre-built adjacency map instead of filtering all edges each call
+        const neighbors = adjacencyMap.get(nodeId) || [];
+        for (const target of neighbors) {
+            if (hasCycleUtil(target))
                 return true;
         }
         recursionStack.delete(nodeId);
@@ -312,6 +324,19 @@ export function hasCycles(nodes, edges) {
 export function hasInvalidCycles(nodes, edges) {
     // Filter out loopback edges - these create valid cycles for loop iteration
     const nonLoopbackEdges = edges.filter((edge) => !isLoopbackEdge(edge));
+    // Build adjacency map from non-loopback edges once (O(E)) so the DFS inner
+    // loop is O(1) per lookup instead of scanning all edges on every recursive
+    // call (which was O(V*E)).
+    const adjacencyMap = new Map();
+    for (const node of nodes) {
+        adjacencyMap.set(node.id, []);
+    }
+    for (const edge of nonLoopbackEdges) {
+        const neighbors = adjacencyMap.get(edge.source);
+        if (neighbors) {
+            neighbors.push(edge.target);
+        }
+    }
     // Check for cycles using only non-loopback edges
     const visited = new Set();
     const recursionStack = new Set();
@@ -327,10 +352,10 @@ export function hasInvalidCycles(nodes, edges) {
             return false;
         visited.add(nodeId);
         recursionStack.add(nodeId);
-        // Get all outgoing non-loopback edges from this node
-        const outgoingEdges = nonLoopbackEdges.filter((e) => e.source === nodeId);
-        for (const edge of outgoingEdges) {
-            if (hasCycleUtil(edge.target))
+        // Use pre-built adjacency map instead of filtering all edges each call
+        const neighbors = adjacencyMap.get(nodeId) || [];
+        for (const target of neighbors) {
+            if (hasCycleUtil(target))
                 return true;
         }
         recursionStack.delete(nodeId);

package/dist/utils/icons.js

@@ -2,7 +2,7 @@
  * Centralized icon management for FlowDrop
  * Ensures consistent icon usage across all components
  */
-import { getCategoryIcon as getCategoryIconFromStore } from '../stores/categoriesStore.js';
+import { getCategoryIcon as getCategoryIconFromStore } from '../stores/categoriesStore.svelte.js';
 /**
  * Default icons for different contexts
  */

package/dist/utils/logger.d.ts

@@ -0,0 +1,47 @@
+/**
+ * FlowDrop Logger
+ *
+ * Lightweight configurable logger for the FlowDrop library.
+ * Disabled by default — consumers enable it for debugging.
+ *
+ * @module utils/logger
+ *
+ * @example
+ * ```typescript
+ * import { setLogLevel } from '@d34dman/flowdrop/core';
+ *
+ * // Enable debug logging during development
+ * setLogLevel('debug');
+ *
+ * // Enable only warnings and errors
+ * setLogLevel('warn');
+ *
+ * // Disable all logging (default)
+ * setLogLevel('none');
+ * ```
+ */
+/** Log severity levels. `'none'` disables all output. */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'none';
+/**
+ * Set the minimum log level for FlowDrop library output.
+ * Messages below this level are silently discarded.
+ *
+ * @param level - The minimum severity to display. Use `'none'` to disable all output.
+ */
+export declare function setLogLevel(level: LogLevel): void;
+/**
+ * Get the current log level.
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * FlowDrop library logger.
+ *
+ * All methods are no-ops when the log level is set to `'none'` (default).
+ * Enable output by calling `setLogLevel()`.
+ */
+export declare const logger: {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,72 @@
+/**
+ * FlowDrop Logger
+ *
+ * Lightweight configurable logger for the FlowDrop library.
+ * Disabled by default — consumers enable it for debugging.
+ *
+ * @module utils/logger
+ *
+ * @example
+ * ```typescript
+ * import { setLogLevel } from '@d34dman/flowdrop/core';
+ *
+ * // Enable debug logging during development
+ * setLogLevel('debug');
+ *
+ * // Enable only warnings and errors
+ * setLogLevel('warn');
+ *
+ * // Disable all logging (default)
+ * setLogLevel('none');
+ * ```
+ */
+const LOG_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    none: 4
+};
+let currentLevel = 'none';
+/**
+ * Set the minimum log level for FlowDrop library output.
+ * Messages below this level are silently discarded.
+ *
+ * @param level - The minimum severity to display. Use `'none'` to disable all output.
+ */
+export function setLogLevel(level) {
+    currentLevel = level;
+}
+/**
+ * Get the current log level.
+ */
+export function getLogLevel() {
+    return currentLevel;
+}
+function shouldLog(level) {
+    return LOG_PRIORITY[level] >= LOG_PRIORITY[currentLevel];
+}
+/**
+ * FlowDrop library logger.
+ *
+ * All methods are no-ops when the log level is set to `'none'` (default).
+ * Enable output by calling `setLogLevel()`.
+ */
+export const logger = {
+    debug(message, ...args) {
+        if (shouldLog('debug'))
+            console.debug(`[FlowDrop] ${message}`, ...args);
+    },
+    info(message, ...args) {
+        if (shouldLog('info'))
+            console.info(`[FlowDrop] ${message}`, ...args);
+    },
+    warn(message, ...args) {
+        if (shouldLog('warn'))
+            console.warn(`[FlowDrop] ${message}`, ...args);
+    },
+    error(message, ...args) {
+        if (shouldLog('error'))
+            console.error(`[FlowDrop] ${message}`, ...args);
+    }
+};

package/dist/utils/nodeWrapper.js

@@ -19,7 +19,7 @@ export function createNodeWrapperConfig(nodeId, executionInfo, config = {}) {
         executionInfo,
         statusPosition: config.position || DEFAULT_NODE_STATUS_CONFIG.position,
         statusSize: config.size || DEFAULT_NODE_STATUS_CONFIG.size,
-        showStatusDetails: config.showDetails ?? DEFAULT_NODE_STATUS_CONFIG.showDetails
+        showStatusDetails: config.showDetails ?? DEFAULT_NODE_STATUS_CONFIG.showDetails ?? true
     };
 }
 /**

package/dist/utils/sanitize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sanitize an HTML string to prevent XSS attacks.
+ *
+ * Uses DOMPurify defaults which strip dangerous elements (script, iframe, object)
+ * and event handler attributes (onerror, onclick, etc.) while preserving safe HTML
+ * elements typically produced by markdown renderers.
+ *
+ * @param dirty - The untrusted HTML string to sanitize
+ * @returns Sanitized HTML string safe for use with {@html}
+ *
+ * @example
+ * ```typescript
+ * import { sanitizeHtml } from '@d34dman/flowdrop/core';
+ * import { marked } from 'marked';
+ *
+ * const safeHtml = sanitizeHtml(marked.parse(userInput) as string);
+ * ```
+ */
+export declare function sanitizeHtml(dirty: string): string;

package/dist/utils/sanitize.js

@@ -0,0 +1,31 @@
+/**
+ * HTML Sanitization Utility
+ *
+ * Provides XSS protection for rendered HTML content using DOMPurify.
+ * Used internally by components that render user-provided or API-provided HTML
+ * (e.g., markdown output, interrupt review diffs).
+ *
+ * @module utils/sanitize
+ */
+import DOMPurify from 'dompurify';
+/**
+ * Sanitize an HTML string to prevent XSS attacks.
+ *
+ * Uses DOMPurify defaults which strip dangerous elements (script, iframe, object)
+ * and event handler attributes (onerror, onclick, etc.) while preserving safe HTML
+ * elements typically produced by markdown renderers.
+ *
+ * @param dirty - The untrusted HTML string to sanitize
+ * @returns Sanitized HTML string safe for use with {@html}
+ *
+ * @example
+ * ```typescript
+ * import { sanitizeHtml } from '@d34dman/flowdrop/core';
+ * import { marked } from 'marked';
+ *
+ * const safeHtml = sanitizeHtml(marked.parse(userInput) as string);
+ * ```
+ */
+export function sanitizeHtml(dirty) {
+    return DOMPurify.sanitize(dirty);
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,29 @@
+/**
+ * FlowDrop Workflow Validation
+ *
+ * Lightweight validation utilities for workflow JSON data.
+ * Checks minimum required fields without relying on a full JSON Schema validator library.
+ *
+ * @module utils/validation
+ */
+/**
+ * Result of a workflow validation check.
+ */
+export interface WorkflowValidationResult {
+    valid: boolean;
+    /** Human-readable description of the first validation failure, or undefined if valid. */
+    error?: string;
+}
+/**
+ * Validate that the given value has the minimum required fields of a FlowDrop Workflow.
+ *
+ * Required fields (matching the Workflow type and workflow.schema.json):
+ * - `id`    — string
+ * - `name`  — string
+ * - `nodes` — array
+ * - `edges` — array
+ *
+ * @param data - The parsed JSON value to validate.
+ * @returns A `WorkflowValidationResult` indicating whether the data is valid.
+ */
+export declare function validateWorkflowData(data: unknown): WorkflowValidationResult;

package/dist/utils/validation.js

@@ -0,0 +1,39 @@
+/**
+ * FlowDrop Workflow Validation
+ *
+ * Lightweight validation utilities for workflow JSON data.
+ * Checks minimum required fields without relying on a full JSON Schema validator library.
+ *
+ * @module utils/validation
+ */
+/**
+ * Validate that the given value has the minimum required fields of a FlowDrop Workflow.
+ *
+ * Required fields (matching the Workflow type and workflow.schema.json):
+ * - `id`    — string
+ * - `name`  — string
+ * - `nodes` — array
+ * - `edges` — array
+ *
+ * @param data - The parsed JSON value to validate.
+ * @returns A `WorkflowValidationResult` indicating whether the data is valid.
+ */
+export function validateWorkflowData(data) {
+    if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+        return { valid: false, error: 'Workflow must be a JSON object.' };
+    }
+    const obj = data;
+    if (typeof obj.id !== 'string' || obj.id.trim() === '') {
+        return { valid: false, error: 'Workflow JSON must contain a non-empty string "id" field.' };
+    }
+    if (typeof obj.name !== 'string' || obj.name.trim() === '') {
+        return { valid: false, error: 'Workflow JSON must contain a non-empty string "name" field.' };
+    }
+    if (!Array.isArray(obj.nodes)) {
+        return { valid: false, error: 'Workflow JSON must contain a "nodes" array.' };
+    }
+    if (!Array.isArray(obj.edges)) {
+        return { valid: false, error: 'Workflow JSON must contain an "edges" array.' };
+    }
+    return { valid: true };
+}