@d34dman/flowdrop 0.0.61 → 0.0.62

package/dist/stores/{interruptStore.js → interruptStore.svelte.js}

@@ -1,75 +1,86 @@
 /**
- * Interrupt Store
+ * Interrupt Store (Svelte 5 Runes)
  *
- * Svelte stores for managing interrupt state using a lightweight state machine.
+ * Rune-based reactive state for managing interrupt state using a lightweight state machine.
  * Ensures valid state transitions and prevents deadlocks.
  *
  * @module stores/interruptStore
  */
-import { writable, derived, get } from 'svelte/store';
+import { SvelteMap } from 'svelte/reactivity';
 import { initialState, transition, isTerminalState, isSubmitting as checkIsSubmitting, hasError as checkHasError, getErrorMessage, getResolvedValue, toLegacyStatus } from '../types/interruptState.js';
+import { logger } from '../utils/logger.js';
 // =========================================================================
-// Core Stores
+// Core Reactive State
 // =========================================================================
 /**
- * Map of all interrupts by ID
+ * Reactive map of all interrupts by ID.
+ * Uses SvelteMap for deep reactivity with Svelte 5 runes.
  * Key: interrupt ID, Value: Interrupt object with state
  */
-export const interrupts = writable(new Map());
+let interrupts = $state(new SvelteMap());
 // =========================================================================
-// Derived Stores
+// Getter Functions (replace derived stores)
 // =========================================================================
 /**
- * Derived store for pending interrupt IDs
+ * Get the reactive interrupts map.
+ * Use this in components within $derived() for reactivity.
  */
-export const pendingInterruptIds = derived(interrupts, ($interrupts) => {
+export function getInterruptsMap() {
+    return interrupts;
+}
+/**
+ * Get pending interrupt IDs (interrupts not in a terminal state)
+ */
+export function getPendingInterruptIds() {
     const pending = [];
-    $interrupts.forEach((interrupt, id) => {
+    interrupts.forEach((interrupt, id) => {
         if (!isTerminalState(interrupt.machineState)) {
             pending.push(id);
         }
     });
     return pending;
-});
+}
 /**
- * Derived store for pending interrupts array
+ * Get pending interrupts array (interrupts not in a terminal state)
  */
-export const pendingInterrupts = derived(interrupts, ($interrupts) => {
+export function getPendingInterrupts() {
     const pending = [];
-    $interrupts.forEach((interrupt) => {
+    interrupts.forEach((interrupt) => {
         if (!isTerminalState(interrupt.machineState)) {
             pending.push(interrupt);
         }
     });
     return pending;
-});
+}
 /**
- * Derived store for count of pending interrupts
+ * Get count of pending interrupts
  */
-export const pendingInterruptCount = derived(pendingInterruptIds, ($pendingIds) => $pendingIds.length);
+export function getPendingInterruptCount() {
+    return getPendingInterruptIds().length;
+}
 /**
- * Derived store for resolved interrupts
+ * Get resolved interrupts array
  */
-export const resolvedInterrupts = derived(interrupts, ($interrupts) => {
+export function getResolvedInterrupts() {
     const resolved = [];
-    $interrupts.forEach((interrupt) => {
+    interrupts.forEach((interrupt) => {
         if (interrupt.machineState.status === 'resolved') {
             resolved.push(interrupt);
         }
     });
     return resolved;
-});
+}
 /**
- * Derived store to check if any interrupt is currently submitting
+ * Check if any interrupt is currently submitting
  */
-export const isAnySubmitting = derived(interrupts, ($interrupts) => {
-    for (const interrupt of $interrupts.values()) {
+export function getIsAnySubmitting() {
+    for (const interrupt of interrupts.values()) {
         if (checkIsSubmitting(interrupt.machineState)) {
             return true;
         }
     }
     return false;
-});
+}
 // =========================================================================
 // State Machine Actions
 // =========================================================================
@@ -81,8 +92,7 @@ export const isAnySubmitting = derived(interrupts, ($interrupts) => {
  * @returns Transition result with validity and any errors
  */
 function applyAction(interruptId, action) {
-    const currentInterrupts = get(interrupts);
-    const interrupt = currentInterrupts.get(interruptId);
+    const interrupt = interrupts.get(interruptId);
     if (!interrupt) {
         return {
             state: initialState,
@@ -92,29 +102,25 @@ function applyAction(interruptId, action) {
     }
     const result = transition(interrupt.machineState, action);
     if (result.valid) {
-        interrupts.update(($interrupts) => {
-            const updated = new Map($interrupts);
-            const current = updated.get(interruptId);
-            if (current) {
-                // Update machine state and sync legacy fields
-                const newInterrupt = {
-                    ...current,
-                    machineState: result.state,
-                    status: toLegacyStatus(result.state),
-                    responseValue: getResolvedValue(result.state) ?? current.responseValue,
-                    resolvedAt: result.state.status === 'resolved'
-                        ? result.state.resolvedAt
-                        : result.state.status === 'cancelled'
-                            ? result.state.cancelledAt
-                            : current.resolvedAt
-                };
-                updated.set(interruptId, newInterrupt);
-            }
-            return updated;
-        });
+        const current = interrupts.get(interruptId);
+        if (current) {
+            // Update machine state and sync legacy fields
+            const newInterrupt = {
+                ...current,
+                machineState: result.state,
+                status: toLegacyStatus(result.state),
+                responseValue: getResolvedValue(result.state) ?? current.responseValue,
+                resolvedAt: result.state.status === 'resolved'
+                    ? result.state.resolvedAt
+                    : result.state.status === 'cancelled'
+                        ? result.state.cancelledAt
+                        : current.resolvedAt
+            };
+            interrupts.set(interruptId, newInterrupt);
+        }
     }
     else {
-        console.warn(`[InterruptStore] Invalid transition: ${result.error}`);
+        logger.warn(`[InterruptStore] Invalid transition: ${result.error}`);
     }
     return result;
 }
@@ -131,18 +137,14 @@ export const interruptActions = {
      * @param interrupt - The interrupt to add or update
      */
     addInterrupt: (interrupt) => {
-        interrupts.update(($interrupts) => {
-            const updated = new Map($interrupts);
-            const existing = updated.get(interrupt.id);
-            // Preserve existing machine state if interrupt already exists
-            const machineState = existing?.machineState ?? initialState;
-            const interruptWithState = {
-                ...interrupt,
-                machineState
-            };
-            updated.set(interrupt.id, interruptWithState);
-            return updated;
-        });
+        const existing = interrupts.get(interrupt.id);
+        // Preserve existing machine state if interrupt already exists
+        const machineState = existing?.machineState ?? initialState;
+        const interruptWithState = {
+            ...interrupt,
+            machineState
+        };
+        interrupts.set(interrupt.id, interruptWithState);
     },
     /**
      * Add multiple interrupts to the store
@@ -152,18 +154,14 @@ export const interruptActions = {
     addInterrupts: (interruptList) => {
         if (interruptList.length === 0)
             return;
-        interrupts.update(($interrupts) => {
-            const updated = new Map($interrupts);
-            interruptList.forEach((interrupt) => {
-                const existing = updated.get(interrupt.id);
-                const machineState = existing?.machineState ?? initialState;
-                const interruptWithState = {
-                    ...interrupt,
-                    machineState
-                };
-                updated.set(interrupt.id, interruptWithState);
-            });
-            return updated;
+        interruptList.forEach((interrupt) => {
+            const existing = interrupts.get(interrupt.id);
+            const machineState = existing?.machineState ?? initialState;
+            const interruptWithState = {
+                ...interrupt,
+                machineState
+            };
+            interrupts.set(interrupt.id, interruptWithState);
         });
     },
     /**
@@ -251,11 +249,7 @@ export const interruptActions = {
      * @param interruptId - The interrupt ID to remove
      */
     removeInterrupt: (interruptId) => {
-        interrupts.update(($interrupts) => {
-            const updated = new Map($interrupts);
-            updated.delete(interruptId);
-            return updated;
-        });
+        interrupts.delete(interruptId);
     },
     /**
      * Clear all interrupts for a specific session
@@ -263,27 +257,25 @@ export const interruptActions = {
      * @param sessionId - The session ID to clear interrupts for
      */
     clearSessionInterrupts: (sessionId) => {
-        interrupts.update(($interrupts) => {
-            const updated = new Map($interrupts);
-            $interrupts.forEach((interrupt, id) => {
-                if (interrupt.sessionId === sessionId) {
-                    updated.delete(id);
-                }
-            });
-            return updated;
+        const toDelete = [];
+        interrupts.forEach((interrupt, id) => {
+            if (interrupt.sessionId === sessionId) {
+                toDelete.push(id);
+            }
         });
+        toDelete.forEach((id) => interrupts.delete(id));
     },
     /**
      * Alias for clearSessionInterrupts
      */
     clearInterrupts: () => {
-        interrupts.set(new Map());
+        interrupts.clear();
     },
     /**
      * Reset all interrupt state
      */
     reset: () => {
-        interrupts.set(new Map());
+        interrupts.clear();
     }
 };
 // =========================================================================
@@ -296,7 +288,7 @@ export const interruptActions = {
  * @returns The interrupt or undefined
  */
 export function getInterrupt(interruptId) {
-    return get(interrupts).get(interruptId);
+    return interrupts.get(interruptId);
 }
 /**
  * Check if an interrupt is pending (not resolved or cancelled)
@@ -305,7 +297,7 @@ export function getInterrupt(interruptId) {
  * @returns True if the interrupt exists and is pending
  */
 export function isInterruptPending(interruptId) {
-    const interrupt = get(interrupts).get(interruptId);
+    const interrupt = interrupts.get(interruptId);
     return interrupt ? !isTerminalState(interrupt.machineState) : false;
 }
 /**
@@ -315,7 +307,7 @@ export function isInterruptPending(interruptId) {
  * @returns True if the interrupt is being submitted
  */
 export function isInterruptSubmitting(interruptId) {
-    const interrupt = get(interrupts).get(interruptId);
+    const interrupt = interrupts.get(interruptId);
     return interrupt ? checkIsSubmitting(interrupt.machineState) : false;
 }
 /**
@@ -325,7 +317,7 @@ export function isInterruptSubmitting(interruptId) {
  * @returns The error message or undefined
  */
 export function getInterruptError(interruptId) {
-    const interrupt = get(interrupts).get(interruptId);
+    const interrupt = interrupts.get(interruptId);
     return interrupt ? getErrorMessage(interrupt.machineState) : undefined;
 }
 /**
@@ -335,8 +327,7 @@ export function getInterruptError(interruptId) {
  * @returns The interrupt or undefined
  */
 export function getInterruptByMessageId(messageId) {
-    const interruptMap = get(interrupts);
-    for (const interrupt of interruptMap.values()) {
+    for (const interrupt of interrupts.values()) {
         if (interrupt.messageId === messageId) {
             return interrupt;
         }
@@ -350,6 +341,6 @@ export function getInterruptByMessageId(messageId) {
  * @returns True if the interrupt has an error
  */
 export function interruptHasError(interruptId) {
-    const interrupt = get(interrupts).get(interruptId);
+    const interrupt = interrupts.get(interruptId);
     return interrupt ? checkHasError(interrupt.machineState) : false;
 }

package/dist/stores/{playgroundStore.d.ts → playgroundStore.svelte.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Playground Store
  *
- * Svelte stores for managing playground state including sessions,
+ * Svelte 5 rune-based state for managing playground state including sessions,
  * messages, and execution status.
  *
  * @module stores/playgroundStore
@@ -9,72 +9,72 @@
 import type { PlaygroundSession, PlaygroundMessage, PlaygroundInputField, PlaygroundSessionStatus, PlaygroundMessagesApiResponse } from '../types/playground.js';
 import type { Workflow } from '../types/index.js';
 /**
- * Currently active playground session
+ * Get the current session
  */
-export declare const currentSession: import("svelte/store").Writable<PlaygroundSession>;
+export declare function getCurrentSession(): PlaygroundSession | null;
 /**
- * List of all sessions for the current workflow
+ * Get all sessions
  */
-export declare const sessions: import("svelte/store").Writable<PlaygroundSession[]>;
+export declare function getSessions(): PlaygroundSession[];
 /**
- * Messages in the current session
+ * Get all messages
  */
-export declare const messages: import("svelte/store").Writable<PlaygroundMessage[]>;
+export declare function getMessages(): PlaygroundMessage[];
 /**
- * Whether an execution is currently running
+ * Get executing state
  */
-export declare const isExecuting: import("svelte/store").Writable<boolean>;
+export declare function getIsExecuting(): boolean;
 /**
- * Whether we are currently loading data
+ * Get loading state
  */
-export declare const isLoading: import("svelte/store").Writable<boolean>;
+export declare function getIsLoading(): boolean;
 /**
- * Current error message, if any
+ * Get error state
  */
-export declare const error: import("svelte/store").Writable<string>;
+export declare function getError(): string | null;
 /**
- * Current workflow being tested
+ * Get the current workflow
  */
-export declare const currentWorkflow: import("svelte/store").Writable<Workflow>;
+export declare function getCurrentWorkflow(): Workflow | null;
 /**
- * Last polling timestamp for incremental message fetching
+ * Get the last poll timestamp
  */
-export declare const lastPollTimestamp: import("svelte/store").Writable<string>;
+export declare function getLastPollTimestamp(): string | null;
 /**
- * Derived store for current session status
+ * Get current session status
  */
-export declare const sessionStatus: import("svelte/store").Readable<PlaygroundSessionStatus>;
+export declare function getSessionStatus(): PlaygroundSessionStatus;
 /**
- * Derived store for message count
+ * Get message count
  */
-export declare const messageCount: import("svelte/store").Readable<number>;
+export declare function getMessageCount(): number;
 /**
- * Derived store for chat messages (excludes log messages)
+ * Get chat messages (excludes log messages)
  */
-export declare const chatMessages: import("svelte/store").Readable<PlaygroundMessage[]>;
+export declare function getChatMessages(): PlaygroundMessage[];
 /**
- * Derived store for log messages only
+ * Get log messages only
  */
-export declare const logMessages: import("svelte/store").Readable<PlaygroundMessage[]>;
+export declare function getLogMessages(): PlaygroundMessage[];
 /**
- * Derived store for the latest message
+ * Get the latest message
  */
-export declare const latestMessage: import("svelte/store").Readable<PlaygroundMessage>;
+export declare function getLatestMessage(): PlaygroundMessage | null;
 /**
- * Derived store for input fields from workflow input nodes
+ * Get input fields from workflow input nodes
  *
  * Analyzes the workflow to extract input nodes and their configuration
  * schemas for auto-generating input forms.
  */
-export declare const inputFields: import("svelte/store").Readable<PlaygroundInputField[]>;
+export declare function getInputFields(): PlaygroundInputField[];
 /**
- * Derived store for detecting if workflow has a chat input
+ * Check if workflow has a chat input
  */
-export declare const hasChatInput: import("svelte/store").Readable<boolean>;
+export declare function getHasChatInput(): boolean;
 /**
- * Derived store for session count
+ * Get session count
  */
-export declare const sessionCount: import("svelte/store").Readable<number>;
+export declare function getSessionCount(): number;
 /**
  * Playground store actions for modifying state
  */
@@ -209,6 +209,14 @@ export declare function getMessagesSnapshot(): PlaygroundMessage[];
  * @returns ISO 8601 timestamp of the latest message, or null
  */
 export declare function getLatestMessageTimestamp(): string | null;
+/**
+ * Subscribe to session status changes using $effect.root.
+ * This is designed for use in non-component contexts (e.g., mount.ts).
+ *
+ * @param callback - Called when session status changes
+ * @returns Cleanup function to stop the subscription
+ */
+export declare function subscribeToSessionStatus(callback: (status: PlaygroundSessionStatus, previousStatus: PlaygroundSessionStatus) => void): () => void;
 /**
  * Refresh messages for the current session
  *