diff --git a/apps/sim/app/(landing)/components/hero-workflow.tsx b/apps/sim/app/(landing)/components/hero-workflow.tsx
index 592f0b33fa4..727847dff57 100644
--- a/apps/sim/app/(landing)/components/hero-workflow.tsx
+++ b/apps/sim/app/(landing)/components/hero-workflow.tsx
@@ -154,7 +154,7 @@ const mobileEdges: Edge[] = [
 
 const workflowVariants = {
   hidden: { opacity: 0, scale: 0.98 },
-  visible: { opacity: 1, scale: 1, transition: { duration: 0.5, delay: 0.1 } },
+  visible: { opacity: 1, scale: 1 },
 }
 
 export function HeroWorkflow() {
@@ -208,6 +208,7 @@ export function HeroWorkflow() {
       variants={workflowVariants}
       initial='hidden'
       animate='visible'
+      transition={{ duration: 0.5, delay: 0.1, ease: 'easeOut' }}
     >
       <style jsx global>{`
         .react-flow__edge-path {
diff --git a/apps/sim/app/(landing)/components/nav-client.tsx b/apps/sim/app/(landing)/components/nav-client.tsx
index ea08ba43da1..9c3096108b3 100644
--- a/apps/sim/app/(landing)/components/nav-client.tsx
+++ b/apps/sim/app/(landing)/components/nav-client.tsx
@@ -44,13 +44,7 @@ const mobileSheetContainerVariants = {
 
 const mobileNavItemsContainerVariants = {
   hidden: { opacity: 0 },
-  visible: {
-    opacity: 1,
-    transition: {
-      delayChildren: 0.1, // Delay before starting stagger
-      staggerChildren: 0.08, // Stagger delay between items
-    },
-  },
+  visible: { opacity: 1 },
 }
 
 const mobileNavItemVariants = {
@@ -217,6 +211,7 @@ export default function NavClient({
             variants={desktopNavContainerVariants}
             initial='hidden'
             animate='visible'
+            transition={{ delay: 0.2, duration: 0.3, ease: 'easeOut' }}
           >
             <NavLinks currentPath={currentPath} onContactClick={onContactClick} />
           </motion.div>
@@ -265,6 +260,7 @@ export default function NavClient({
                       initial='hidden'
                       animate='visible'
                       exit='exit'
+                      transition={{ duration: 0.3, ease: 'easeInOut' }}
                       className='fixed inset-y-0 right-0 z-50'
                     >
                       <SheetContent
@@ -281,6 +277,10 @@ export default function NavClient({
                           variants={mobileNavItemsContainerVariants}
                           initial='hidden'
                           animate='visible'
+                          transition={{
+                            delayChildren: 0.1,
+                            staggerChildren: 0.08,
+                          }}
                         >
                           <NavLinks
                             mobile
diff --git a/apps/sim/app/api/auth/socket-token/route.ts b/apps/sim/app/api/auth/socket-token/route.ts
new file mode 100644
index 00000000000..1f28ab6d7cc
--- /dev/null
+++ b/apps/sim/app/api/auth/socket-token/route.ts
@@ -0,0 +1,20 @@
+import { headers } from 'next/headers'
+import { NextResponse } from 'next/server'
+import { auth } from '@/lib/auth'
+
+export async function POST() {
+  try {
+    const response = await auth.api.generateOneTimeToken({
+      headers: await headers(),
+    })
+
+    if (!response) {
+      return NextResponse.json({ error: 'Failed to generate token' }, { status: 500 })
+    }
+
+    return NextResponse.json({ token: response.token })
+  } catch (error) {
+    console.error('Error generating one-time token:', error)
+    return NextResponse.json({ error: 'Failed to generate token' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/workflows/[id]/deploy/route.test.ts b/apps/sim/app/api/workflows/[id]/deploy/route.test.ts
index 88f6640ab02..8fb1344998a 100644
--- a/apps/sim/app/api/workflows/[id]/deploy/route.test.ts
+++ b/apps/sim/app/api/workflows/[id]/deploy/route.test.ts
@@ -129,6 +129,33 @@ describe('Workflow Deployment API Route', () => {
               }),
             }),
           })
+          // Mock normalized table queries (blocks, edges, subflows)
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([
+                {
+                  id: 'block-1',
+                  type: 'starter',
+                  name: 'Start',
+                  positionX: '100',
+                  positionY: '100',
+                  enabled: true,
+                  subBlocks: {},
+                  data: {},
+                },
+              ]),
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No edges
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No subflows
+            }),
+          })
           .mockReturnValueOnce({
             from: vi.fn().mockReturnValue({
               where: vi.fn().mockReturnValue({
@@ -189,6 +216,33 @@ describe('Workflow Deployment API Route', () => {
               }),
             }),
           })
+          // Mock normalized table queries (blocks, edges, subflows)
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([
+                {
+                  id: 'block-1',
+                  type: 'starter',
+                  name: 'Start',
+                  positionX: '100',
+                  positionY: '100',
+                  enabled: true,
+                  subBlocks: {},
+                  data: {},
+                },
+              ]),
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No edges
+            }),
+          })
+          .mockReturnValueOnce({
+            from: vi.fn().mockReturnValue({
+              where: vi.fn().mockResolvedValue([]), // No subflows
+            }),
+          })
           .mockReturnValueOnce({
             from: vi.fn().mockReturnValue({
               where: vi.fn().mockReturnValue({
diff --git a/apps/sim/app/api/workflows/[id]/deploy/route.ts b/apps/sim/app/api/workflows/[id]/deploy/route.ts
index 0fcf0e184eb..afd03d57806 100644
--- a/apps/sim/app/api/workflows/[id]/deploy/route.ts
+++ b/apps/sim/app/api/workflows/[id]/deploy/route.ts
@@ -4,7 +4,7 @@ import { v4 as uuidv4 } from 'uuid'
 import { createLogger } from '@/lib/logs/console-logger'
 import { generateApiKey } from '@/lib/utils'
 import { db } from '@/db'
-import { apiKey, workflow } from '@/db/schema'
+import { apiKey, workflow, workflowBlocks, workflowEdges, workflowSubflows } from '@/db/schema'
 import { validateWorkflowAccess } from '../../middleware'
 import { createErrorResponse, createSuccessResponse } from '../../utils'
 
@@ -126,7 +126,7 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
       return createErrorResponse(validation.error.message, validation.error.status)
     }
 
-    // Get the workflow to find the user and current state
+    // Get the workflow to find the user
     const workflowData = await db
       .select({
         userId: workflow.userId,
@@ -142,8 +142,92 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     }
 
     const userId = workflowData[0].userId
-    const currentState = workflowData[0].state
+
+    // Get the current live state from normalized tables instead of stale JSON
+    logger.debug(`[${requestId}] Getting current workflow state for deployment`)
+
+    // Get blocks from normalized table
+    const blocks = await db.select().from(workflowBlocks).where(eq(workflowBlocks.workflowId, id))
+
+    // Get edges from normalized table
+    const edges = await db.select().from(workflowEdges).where(eq(workflowEdges.workflowId, id))
+
+    // Get subflows from normalized table
+    const subflows = await db
+      .select()
+      .from(workflowSubflows)
+      .where(eq(workflowSubflows.workflowId, id))
+
+    // Build current state from normalized data
+    const blocksMap: Record<string, any> = {}
+    const loops: Record<string, any> = {}
+    const parallels: Record<string, any> = {}
+
+    // Process blocks
+    blocks.forEach((block) => {
+      blocksMap[block.id] = {
+        id: block.id,
+        type: block.type,
+        name: block.name,
+        position: { x: Number(block.positionX), y: Number(block.positionY) },
+        data: block.data,
+        enabled: block.enabled,
+        subBlocks: block.subBlocks || {},
+      }
+    })
+
+    // Process subflows (loops and parallels)
+    subflows.forEach((subflow) => {
+      const config = (subflow.config as any) || {}
+      if (subflow.type === 'loop') {
+        loops[subflow.id] = {
+          nodes: config.nodes || [],
+          iterationCount: config.iterationCount || 1,
+          iterationType: config.iterationType || 'fixed',
+          collection: config.collection || '',
+        }
+      } else if (subflow.type === 'parallel') {
+        parallels[subflow.id] = {
+          nodes: config.nodes || [],
+          parallelCount: config.parallelCount || 2,
+          collection: config.collection || '',
+        }
+      }
+    })
+
+    // Convert edges to the expected format
+    const edgesArray = edges.map((edge) => ({
+      id: edge.id,
+      source: edge.sourceBlockId,
+      target: edge.targetBlockId,
+      sourceHandle: edge.sourceHandle,
+      targetHandle: edge.targetHandle,
+      type: 'default',
+      data: {},
+    }))
+
+    const currentState = {
+      blocks: blocksMap,
+      edges: edgesArray,
+      loops,
+      parallels,
+      lastSaved: Date.now(),
+    }
+
+    logger.debug(`[${requestId}] Current state retrieved from normalized tables:`, {
+      blocksCount: Object.keys(blocksMap).length,
+      edgesCount: edgesArray.length,
+      loopsCount: Object.keys(loops).length,
+      parallelsCount: Object.keys(parallels).length,
+    })
+
+    if (!currentState || !currentState.blocks) {
+      logger.error(`[${requestId}] Invalid workflow state retrieved`, { currentState })
+      throw new Error('Invalid workflow state: missing blocks')
+    }
+
     const deployedAt = new Date()
+    logger.debug(`[${requestId}] Proceeding with deployment at ${deployedAt.toISOString()}`)
 
     // Check if the user already has an API key
     const userApiKey = await db
@@ -191,7 +275,13 @@ export async function POST(request: NextRequest, { params }: { params: Promise<{
     logger.info(`[${requestId}] Workflow deployed successfully: ${id}`)
     return createSuccessResponse({ apiKey: userKey, isDeployed: true, deployedAt })
   } catch (error: any) {
-    logger.error(`[${requestId}] Error deploying workflow: ${id}`, error)
+    logger.error(`[${requestId}] Error deploying workflow: ${id}`, {
+      error: error.message,
+      stack: error.stack,
+      name: error.name,
+      cause: error.cause,
+      fullError: error,
+    })
     return createErrorResponse(error.message || 'Failed to deploy workflow', 500)
   }
 }
diff --git a/apps/sim/app/api/workflows/[id]/duplicate/route.ts b/apps/sim/app/api/workflows/[id]/duplicate/route.ts
new file mode 100644
index 00000000000..1c3731b14bb
--- /dev/null
+++ b/apps/sim/app/api/workflows/[id]/duplicate/route.ts
@@ -0,0 +1,369 @@
+import crypto from 'crypto'
+import { and, eq } from 'drizzle-orm'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { getSession } from '@/lib/auth'
+import { createLogger } from '@/lib/logs/console-logger'
+import { db } from '@/db'
+import { workflow, workflowBlocks, workflowEdges, workflowSubflows } from '@/db/schema'
+import type { LoopConfig, ParallelConfig, WorkflowState } from '@/stores/workflows/workflow/types'
+
+const logger = createLogger('WorkflowDuplicateAPI')
+
+const DuplicateRequestSchema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  description: z.string().optional(),
+  color: z.string().optional(),
+  workspaceId: z.string().optional(),
+  folderId: z.string().nullable().optional(),
+})
+
+// POST /api/workflows/[id]/duplicate - Duplicate a workflow with all its blocks, edges, and subflows
+export async function POST(req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const { id: sourceWorkflowId } = await params
+  const requestId = crypto.randomUUID().slice(0, 8)
+  const startTime = Date.now()
+
+  try {
+    const session = await getSession()
+    if (!session?.user?.id) {
+      logger.warn(
+        `[${requestId}] Unauthorized workflow duplication attempt for ${sourceWorkflowId}`
+      )
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const body = await req.json()
+    const { name, description, color, workspaceId, folderId } = DuplicateRequestSchema.parse(body)
+
+    logger.info(
+      `[${requestId}] Duplicating workflow ${sourceWorkflowId} for user ${session.user.id}`
+    )
+
+    // Generate new workflow ID
+    const newWorkflowId = crypto.randomUUID()
+    const now = new Date()
+
+    // Duplicate workflow and all related data in a transaction
+    const result = await db.transaction(async (tx) => {
+      // First verify the source workflow exists and user has access
+      const sourceWorkflow = await tx
+        .select()
+        .from(workflow)
+        .where(and(eq(workflow.id, sourceWorkflowId), eq(workflow.userId, session.user.id)))
+        .limit(1)
+
+      if (sourceWorkflow.length === 0) {
+        throw new Error('Source workflow not found or access denied')
+      }
+
+      const source = sourceWorkflow[0]
+
+      // Create the new workflow first (required for foreign key constraints)
+      await tx.insert(workflow).values({
+        id: newWorkflowId,
+        userId: session.user.id,
+        workspaceId: workspaceId || source.workspaceId,
+        folderId: folderId || source.folderId,
+        name,
+        description: description || source.description,
+        state: source.state, // We'll update this later with new block IDs
+        color: color || source.color,
+        lastSynced: now,
+        createdAt: now,
+        updatedAt: now,
+        isDeployed: false,
+        collaborators: [],
+        runCount: 0,
+        variables: source.variables || {},
+        isPublished: false,
+        marketplaceData: null,
+      })
+
+      // Copy all blocks from source workflow with new IDs
+      const sourceBlocks = await tx
+        .select()
+        .from(workflowBlocks)
+        .where(eq(workflowBlocks.workflowId, sourceWorkflowId))
+
+      // Create a mapping from old block IDs to new block IDs
+      const blockIdMapping = new Map<string, string>()
+
+      // Initialize state for updating with new block IDs
+      let updatedState: WorkflowState = source.state as WorkflowState
+
+      if (sourceBlocks.length > 0) {
+        // First pass: Create all block ID mappings
+        sourceBlocks.forEach((block) => {
+          const newBlockId = crypto.randomUUID()
+          blockIdMapping.set(block.id, newBlockId)
+        })
+
+        // Second pass: Create blocks with updated parent relationships
+        const newBlocks = sourceBlocks.map((block) => {
+          const newBlockId = blockIdMapping.get(block.id)!
+
+          // Update parent ID to point to the new parent block ID if it exists
+          let newParentId = block.parentId
+          if (block.parentId && blockIdMapping.has(block.parentId)) {
+            newParentId = blockIdMapping.get(block.parentId)!
+          }
+
+          // Update data.parentId and extent if they exist in the data object
+          let updatedData = block.data
+          let newExtent = block.extent
+          if (block.data && typeof block.data === 'object' && !Array.isArray(block.data)) {
+            const dataObj = block.data as any
+            if (dataObj.parentId && typeof dataObj.parentId === 'string') {
+              updatedData = { ...dataObj }
+              if (blockIdMapping.has(dataObj.parentId)) {
+                ;(updatedData as any).parentId = blockIdMapping.get(dataObj.parentId)!
+                // Ensure extent is set to 'parent' for child blocks
+                ;(updatedData as any).extent = 'parent'
+                newExtent = 'parent'
+              }
+            }
+          }
+
+          return {
+            ...block,
+            id: newBlockId,
+            workflowId: newWorkflowId,
+            parentId: newParentId,
+            extent: newExtent,
+            data: updatedData,
+            createdAt: now,
+            updatedAt: now,
+          }
+        })
+
+        await tx.insert(workflowBlocks).values(newBlocks)
+        logger.info(
+          `[${requestId}] Copied ${sourceBlocks.length} blocks with updated parent relationships`
+        )
+      }
+
+      // Copy all edges from source workflow with updated block references
+      const sourceEdges = await tx
+        .select()
+        .from(workflowEdges)
+        .where(eq(workflowEdges.workflowId, sourceWorkflowId))
+
+      if (sourceEdges.length > 0) {
+        const newEdges = sourceEdges.map((edge) => ({
+          ...edge,
+          id: crypto.randomUUID(), // Generate new edge ID
+          workflowId: newWorkflowId,
+          sourceBlockId: blockIdMapping.get(edge.sourceBlockId) || edge.sourceBlockId,
+          targetBlockId: blockIdMapping.get(edge.targetBlockId) || edge.targetBlockId,
+          createdAt: now,
+          updatedAt: now,
+        }))
+
+        await tx.insert(workflowEdges).values(newEdges)
+        logger.info(
+          `[${requestId}] Copied ${sourceEdges.length} edges with updated block references`
+        )
+      }
+
+      // Copy all subflows from source workflow with new IDs and updated block references
+      const sourceSubflows = await tx
+        .select()
+        .from(workflowSubflows)
+        .where(eq(workflowSubflows.workflowId, sourceWorkflowId))
+
+      if (sourceSubflows.length > 0) {
+        const newSubflows = sourceSubflows
+          .map((subflow) => {
+            // The subflow ID should match the corresponding block ID
+            const newSubflowId = blockIdMapping.get(subflow.id)
+
+            if (!newSubflowId) {
+              logger.warn(
+                `[${requestId}] Subflow ${subflow.id} (${subflow.type}) has no corresponding block, skipping`
+              )
+              return null
+            }
+
+            logger.info(`[${requestId}] Mapping subflow ${subflow.id} → ${newSubflowId}`, {
+              subflowType: subflow.type,
+            })
+
+            // Update block references in subflow config
+            let updatedConfig: LoopConfig | ParallelConfig = subflow.config as
+              | LoopConfig
+              | ParallelConfig
+            if (subflow.config && typeof subflow.config === 'object') {
+              updatedConfig = JSON.parse(JSON.stringify(subflow.config)) as
+                | LoopConfig
+                | ParallelConfig
+
+              // Update the config ID to match the new subflow ID
+
+              ;(updatedConfig as any).id = newSubflowId
+
+              // Update node references in config if they exist
+              if ('nodes' in updatedConfig && Array.isArray(updatedConfig.nodes)) {
+                updatedConfig.nodes = updatedConfig.nodes.map(
+                  (nodeId: string) => blockIdMapping.get(nodeId) || nodeId
+                )
+              }
+            }
+
+            return {
+              ...subflow,
+              id: newSubflowId, // Use the same ID as the corresponding block
+              workflowId: newWorkflowId,
+              config: updatedConfig,
+              createdAt: now,
+              updatedAt: now,
+            }
+          })
+          .filter((subflow): subflow is NonNullable<typeof subflow> => subflow !== null)
+
+        if (newSubflows.length > 0) {
+          await tx.insert(workflowSubflows).values(newSubflows)
+        }
+
+        logger.info(
+          `[${requestId}] Copied ${newSubflows.length}/${sourceSubflows.length} subflows with updated block references and matching IDs`,
+          {
+            subflowMappings: newSubflows.map((sf) => ({
+              oldId: sourceSubflows.find((s) => blockIdMapping.get(s.id) === sf.id)?.id,
+              newId: sf.id,
+              type: sf.type,
+              config: sf.config,
+            })),
+            blockIdMappings: Array.from(blockIdMapping.entries()).map(([oldId, newId]) => ({
+              oldId,
+              newId,
+            })),
+          }
+        )
+      }
+
+      // Update the JSON state to use new block IDs
+      if (updatedState && typeof updatedState === 'object') {
+        updatedState = JSON.parse(JSON.stringify(updatedState)) as WorkflowState
+
+        // Update blocks object keys
+        if (updatedState.blocks && typeof updatedState.blocks === 'object') {
+          const newBlocks = {} as Record<string, (typeof updatedState.blocks)[string]>
+          for (const [oldId, blockData] of Object.entries(updatedState.blocks)) {
+            const newId = blockIdMapping.get(oldId) || oldId
+            newBlocks[newId] = {
+              ...blockData,
+              id: newId,
+              // Update data.parentId and extent in the JSON state as well
+              data: (() => {
+                const block = blockData as any
+                if (block.data && typeof block.data === 'object' && block.data.parentId) {
+                  return {
+                    ...block.data,
+                    parentId: blockIdMapping.get(block.data.parentId) || block.data.parentId,
+                    extent: 'parent', // Ensure extent is set for child blocks
+                  }
+                }
+                return block.data
+              })(),
+            }
+          }
+          updatedState.blocks = newBlocks
+        }
+
+        // Update edges array
+        if (updatedState.edges && Array.isArray(updatedState.edges)) {
+          updatedState.edges = updatedState.edges.map((edge) => ({
+            ...edge,
+            id: crypto.randomUUID(),
+            source: blockIdMapping.get(edge.source) || edge.source,
+            target: blockIdMapping.get(edge.target) || edge.target,
+          }))
+        }
+
+        // Update loops and parallels if they exist
+        if (updatedState.loops && typeof updatedState.loops === 'object') {
+          const newLoops = {} as Record<string, (typeof updatedState.loops)[string]>
+          for (const [oldId, loopData] of Object.entries(updatedState.loops)) {
+            const newId = blockIdMapping.get(oldId) || oldId
+            const loopConfig = loopData as any
+            newLoops[newId] = {
+              ...loopConfig,
+              id: newId,
+              // Update node references in loop config
+              nodes: loopConfig.nodes
+                ? loopConfig.nodes.map((nodeId: string) => blockIdMapping.get(nodeId) || nodeId)
+                : [],
+            }
+          }
+          updatedState.loops = newLoops
+        }
+
+        if (updatedState.parallels && typeof updatedState.parallels === 'object') {
+          const newParallels = {} as Record<string, (typeof updatedState.parallels)[string]>
+          for (const [oldId, parallelData] of Object.entries(updatedState.parallels)) {
+            const newId = blockIdMapping.get(oldId) || oldId
+            const parallelConfig = parallelData as any
+            newParallels[newId] = {
+              ...parallelConfig,
+              id: newId,
+              // Update node references in parallel config
+              nodes: parallelConfig.nodes
+                ? parallelConfig.nodes.map((nodeId: string) => blockIdMapping.get(nodeId) || nodeId)
+                : [],
+            }
+          }
+          updatedState.parallels = newParallels
+        }
+      }
+
+      // Update the workflow state with the new block IDs
+      await tx
+        .update(workflow)
+        .set({
+          state: updatedState,
+          updatedAt: now,
+        })
+        .where(eq(workflow.id, newWorkflowId))
+
+      return {
+        id: newWorkflowId,
+        name,
+        description: description || source.description,
+        color: color || source.color,
+        workspaceId: workspaceId || source.workspaceId,
+        folderId: folderId || source.folderId,
+        blocksCount: sourceBlocks.length,
+        edgesCount: sourceEdges.length,
+        subflowsCount: sourceSubflows.length,
+      }
+    })
+
+    const elapsed = Date.now() - startTime
+    logger.info(
+      `[${requestId}] Successfully duplicated workflow ${sourceWorkflowId} to ${newWorkflowId} in ${elapsed}ms`
+    )
+
+    return NextResponse.json(result, { status: 201 })
+  } catch (error) {
+    if (error instanceof Error && error.message === 'Source workflow not found or access denied') {
+      logger.warn(`[${requestId}] Source workflow ${sourceWorkflowId} not found or access denied`)
+      return NextResponse.json({ error: 'Source workflow not found' }, { status: 404 })
+    }
+
+    if (error instanceof z.ZodError) {
+      logger.warn(`[${requestId}] Invalid duplication request data`, { errors: error.errors })
+      return NextResponse.json(
+        { error: 'Invalid request data', details: error.errors },
+        { status: 400 }
+      )
+    }
+
+    const elapsed = Date.now() - startTime
+    logger.error(
+      `[${requestId}] Error duplicating workflow ${sourceWorkflowId} after ${elapsed}ms:`,
+      error
+    )
+    return NextResponse.json({ error: 'Failed to duplicate workflow' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/workflows/[id]/route.ts b/apps/sim/app/api/workflows/[id]/route.ts
index 062a0e95e52..2068a201646 100644
--- a/apps/sim/app/api/workflows/[id]/route.ts
+++ b/apps/sim/app/api/workflows/[id]/route.ts
@@ -1,13 +1,28 @@
 import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
 import { getSession } from '@/lib/auth'
 import { createLogger } from '@/lib/logs/console-logger'
 import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/db-helpers'
 import { db } from '@/db'
-import { workflow, workspaceMember } from '@/db/schema'
+import {
+  workflow,
+  workflowBlocks,
+  workflowEdges,
+  workflowSubflows,
+  workspaceMember,
+} from '@/db/schema'
 
 const logger = createLogger('WorkflowByIdAPI')
 
+// Schema for workflow metadata updates
+const UpdateWorkflowSchema = z.object({
+  name: z.string().min(1, 'Name is required').optional(),
+  description: z.string().optional(),
+  color: z.string().optional(),
+  folderId: z.string().nullable().optional(),
+})
+
 /**
  * GET /api/workflows/[id]
  * Fetch a single workflow by ID
@@ -72,11 +87,19 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
     }
 
     // Try to load from normalized tables first
+    logger.debug(`[${requestId}] Attempting to load workflow ${workflowId} from normalized tables`)
     const normalizedData = await loadWorkflowFromNormalizedTables(workflowId)
 
     const finalWorkflowData = { ...workflowData }
 
     if (normalizedData) {
+      logger.debug(`[${requestId}] Found normalized data for workflow ${workflowId}:`, {
+        blocksCount: Object.keys(normalizedData.blocks).length,
+        edgesCount: normalizedData.edges.length,
+        loopsCount: Object.keys(normalizedData.loops).length,
+        parallelsCount: Object.keys(normalizedData.parallels).length,
+        loops: normalizedData.loops,
+      })
       // Use normalized table data - reconstruct complete state object
       // First get any existing state properties, then override with normalized data
       const existingState =
@@ -101,7 +124,9 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
       logger.info(`[${requestId}] Loaded workflow ${workflowId} from normalized tables`)
     } else {
       // Fallback to JSON blob
-      logger.info(`[${requestId}] Using JSON blob for workflow ${workflowId}`)
+      logger.info(
+        `[${requestId}] Using JSON blob for workflow ${workflowId} - no normalized data found`
+      )
     }
 
     const elapsed = Date.now() - startTime
@@ -182,12 +207,48 @@ export async function DELETE(
       return NextResponse.json({ error: 'Access denied' }, { status: 403 })
     }
 
-    // Delete the workflow
-    await db.delete(workflow).where(eq(workflow.id, workflowId))
+    // Delete workflow and all related data in a transaction
+    await db.transaction(async (tx) => {
+      // Delete from normalized tables first (foreign key constraints)
+      await tx.delete(workflowSubflows).where(eq(workflowSubflows.workflowId, workflowId))
+      await tx.delete(workflowEdges).where(eq(workflowEdges.workflowId, workflowId))
+      await tx.delete(workflowBlocks).where(eq(workflowBlocks.workflowId, workflowId))
+
+      // Delete the main workflow record
+      await tx.delete(workflow).where(eq(workflow.id, workflowId))
+    })
 
     const elapsed = Date.now() - startTime
     logger.info(`[${requestId}] Successfully deleted workflow ${workflowId} in ${elapsed}ms`)
 
+    // Notify Socket.IO system to disconnect users from this workflow's room
+    // This prevents "Block not found" errors when collaborative updates try to process
+    // after the workflow has been deleted
+    try {
+      const socketUrl = process.env.SOCKET_SERVER_URL || 'http://localhost:3002'
+      const socketResponse = await fetch(`${socketUrl}/api/workflow-deleted`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ workflowId }),
+      })
+
+      if (socketResponse.ok) {
+        logger.info(
+          `[${requestId}] Notified Socket.IO server about workflow ${workflowId} deletion`
+        )
+      } else {
+        logger.warn(
+          `[${requestId}] Failed to notify Socket.IO server about workflow ${workflowId} deletion`
+        )
+      }
+    } catch (error) {
+      logger.warn(
+        `[${requestId}] Error notifying Socket.IO server about workflow ${workflowId} deletion:`,
+        error
+      )
+      // Don't fail the deletion if Socket.IO notification fails
+    }
+
     return NextResponse.json({ success: true }, { status: 200 })
   } catch (error: any) {
     const elapsed = Date.now() - startTime
@@ -195,3 +256,108 @@ export async function DELETE(
     return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
   }
 }
+
+/**
+ * PUT /api/workflows/[id]
+ * Update workflow metadata (name, description, color, folderId)
+ */
+export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const requestId = crypto.randomUUID().slice(0, 8)
+  const startTime = Date.now()
+  const { id: workflowId } = await params
+
+  try {
+    // Get the session
+    const session = await getSession()
+    if (!session?.user?.id) {
+      logger.warn(`[${requestId}] Unauthorized update attempt for workflow ${workflowId}`)
+      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    }
+
+    const userId = session.user.id
+
+    // Parse and validate request body
+    const body = await request.json()
+    const updates = UpdateWorkflowSchema.parse(body)
+
+    // Fetch the workflow to check ownership/access
+    const workflowData = await db
+      .select()
+      .from(workflow)
+      .where(eq(workflow.id, workflowId))
+      .then((rows) => rows[0])
+
+    if (!workflowData) {
+      logger.warn(`[${requestId}] Workflow ${workflowId} not found for update`)
+      return NextResponse.json({ error: 'Workflow not found' }, { status: 404 })
+    }
+
+    // Check if user has permission to update this workflow
+    let canUpdate = false
+
+    // Case 1: User owns the workflow
+    if (workflowData.userId === userId) {
+      canUpdate = true
+    }
+
+    // Case 2: Workflow belongs to a workspace and user has admin/owner role
+    if (!canUpdate && workflowData.workspaceId) {
+      const membership = await db
+        .select({ role: workspaceMember.role })
+        .from(workspaceMember)
+        .where(
+          and(
+            eq(workspaceMember.workspaceId, workflowData.workspaceId),
+            eq(workspaceMember.userId, userId)
+          )
+        )
+        .then((rows) => rows[0])
+
+      if (membership && (membership.role === 'owner' || membership.role === 'admin')) {
+        canUpdate = true
+      }
+    }
+
+    if (!canUpdate) {
+      logger.warn(
+        `[${requestId}] User ${userId} denied permission to update workflow ${workflowId}`
+      )
+      return NextResponse.json({ error: 'Access denied' }, { status: 403 })
+    }
+
+    // Build update object
+    const updateData: any = { updatedAt: new Date() }
+    if (updates.name !== undefined) updateData.name = updates.name
+    if (updates.description !== undefined) updateData.description = updates.description
+    if (updates.color !== undefined) updateData.color = updates.color
+    if (updates.folderId !== undefined) updateData.folderId = updates.folderId
+
+    // Update the workflow
+    const [updatedWorkflow] = await db
+      .update(workflow)
+      .set(updateData)
+      .where(eq(workflow.id, workflowId))
+      .returning()
+
+    const elapsed = Date.now() - startTime
+    logger.info(`[${requestId}] Successfully updated workflow ${workflowId} in ${elapsed}ms`, {
+      updates: updateData,
+    })
+
+    return NextResponse.json({ workflow: updatedWorkflow }, { status: 200 })
+  } catch (error: any) {
+    const elapsed = Date.now() - startTime
+    if (error instanceof z.ZodError) {
+      logger.warn(`[${requestId}] Invalid workflow update data for ${workflowId}`, {
+        errors: error.errors,
+      })
+      return NextResponse.json(
+        { error: 'Invalid request data', details: error.errors },
+        { status: 400 }
+      )
+    }
+
+    logger.error(`[${requestId}] Error updating workflow ${workflowId} after ${elapsed}ms`, error)
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/workflows/[id]/status/route.ts b/apps/sim/app/api/workflows/[id]/status/route.ts
index bd604cf2647..c2fb40c9001 100644
--- a/apps/sim/app/api/workflows/[id]/status/route.ts
+++ b/apps/sim/app/api/workflows/[id]/status/route.ts
@@ -1,6 +1,9 @@
+import { eq } from 'drizzle-orm'
 import type { NextRequest } from 'next/server'
 import { createLogger } from '@/lib/logs/console-logger'
 import { hasWorkflowChanged } from '@/lib/workflows/utils'
+import { db } from '@/db'
+import { workflowBlocks, workflowEdges, workflowSubflows } from '@/db/schema'
 import { validateWorkflowAccess } from '../../middleware'
 import { createErrorResponse, createSuccessResponse } from '../../utils'
 
@@ -21,8 +24,74 @@ export async function GET(request: NextRequest, { params }: { params: Promise<{
     // Check if the workflow has meaningful changes that would require redeployment
     let needsRedeployment = false
     if (validation.workflow.isDeployed && validation.workflow.deployedState) {
+      // Get current state from normalized tables (same logic as deployment API)
+      const blocks = await db.select().from(workflowBlocks).where(eq(workflowBlocks.workflowId, id))
+
+      const edges = await db.select().from(workflowEdges).where(eq(workflowEdges.workflowId, id))
+
+      const subflows = await db
+        .select()
+        .from(workflowSubflows)
+        .where(eq(workflowSubflows.workflowId, id))
+
+      // Build current state from normalized data
+      const blocksMap: Record<string, any> = {}
+      const loops: Record<string, any> = {}
+      const parallels: Record<string, any> = {}
+
+      // Process blocks
+      blocks.forEach((block) => {
+        blocksMap[block.id] = {
+          id: block.id,
+          type: block.type,
+          name: block.name,
+          position: { x: Number(block.positionX), y: Number(block.positionY) },
+          data: block.data,
+          enabled: block.enabled,
+          subBlocks: block.subBlocks || {},
+        }
+      })
+
+      // Process subflows (loops and parallels)
+      subflows.forEach((subflow) => {
+        const config = (subflow.config as any) || {}
+        if (subflow.type === 'loop') {
+          loops[subflow.id] = {
+            nodes: config.nodes || [],
+            iterationCount: config.iterationCount || 1,
+            iterationType: config.iterationType || 'fixed',
+            collection: config.collection || '',
+          }
+        } else if (subflow.type === 'parallel') {
+          parallels[subflow.id] = {
+            nodes: config.nodes || [],
+            parallelCount: config.parallelCount || 2,
+            collection: config.collection || '',
+          }
+        }
+      })
+
+      // Convert edges to the expected format
+      const edgesArray = edges.map((edge) => ({
+        id: edge.id,
+        source: edge.sourceBlockId,
+        target: edge.targetBlockId,
+        sourceHandle: edge.sourceHandle,
+        targetHandle: edge.targetHandle,
+        type: 'default',
+        data: {},
+      }))
+
+      const currentState = {
+        blocks: blocksMap,
+        edges: edgesArray,
+        loops,
+        parallels,
+        lastSaved: Date.now(),
+      }
+
       needsRedeployment = hasWorkflowChanged(
-        validation.workflow.state as any,
+        currentState as any,
         validation.workflow.deployedState as any
       )
     }
diff --git a/apps/sim/app/api/workflows/route.ts b/apps/sim/app/api/workflows/route.ts
new file mode 100644
index 00000000000..3e698468c15
--- /dev/null
+++ b/apps/sim/app/api/workflows/route.ts
@@ -0,0 +1,290 @@
+import crypto from 'crypto'
+import { type NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { getSession } from '@/lib/auth'
+import { createLogger } from '@/lib/logs/console-logger'
+import { db } from '@/db'
+import { workflow, workflowBlocks } from '@/db/schema'
+
+const logger = createLogger('WorkflowAPI')
+
+// Schema for workflow creation
+const CreateWorkflowSchema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  description: z.string().optional().default(''),
+  color: z.string().optional().default('#3972F6'),
+  workspaceId: z.string().optional(),
+  folderId: z.string().nullable().optional(),
+})
+
+// POST /api/workflows - Create a new workflow
+export async function POST(req: NextRequest) {
+  const requestId = crypto.randomUUID().slice(0, 8)
+  const session = await getSession()
+
+  if (!session?.user?.id) {
+    logger.warn(`[${requestId}] Unauthorized workflow creation attempt`)
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  try {
+    const body = await req.json()
+    const { name, description, color, workspaceId, folderId } = CreateWorkflowSchema.parse(body)
+
+    const workflowId = crypto.randomUUID()
+    const starterId = crypto.randomUUID()
+    const now = new Date()
+
+    logger.info(`[${requestId}] Creating workflow ${workflowId} for user ${session.user.id}`)
+
+    // Create initial state with start block
+    const initialState = {
+      blocks: {
+        [starterId]: {
+          id: starterId,
+          type: 'starter',
+          name: 'Start',
+          position: { x: 100, y: 100 },
+          subBlocks: {
+            startWorkflow: {
+              id: 'startWorkflow',
+              type: 'dropdown',
+              value: 'manual',
+            },
+            webhookPath: {
+              id: 'webhookPath',
+              type: 'short-input',
+              value: '',
+            },
+            webhookSecret: {
+              id: 'webhookSecret',
+              type: 'short-input',
+              value: '',
+            },
+            scheduleType: {
+              id: 'scheduleType',
+              type: 'dropdown',
+              value: 'daily',
+            },
+            minutesInterval: {
+              id: 'minutesInterval',
+              type: 'short-input',
+              value: '',
+            },
+            minutesStartingAt: {
+              id: 'minutesStartingAt',
+              type: 'short-input',
+              value: '',
+            },
+            hourlyMinute: {
+              id: 'hourlyMinute',
+              type: 'short-input',
+              value: '',
+            },
+            dailyTime: {
+              id: 'dailyTime',
+              type: 'short-input',
+              value: '',
+            },
+            weeklyDay: {
+              id: 'weeklyDay',
+              type: 'dropdown',
+              value: 'MON',
+            },
+            weeklyDayTime: {
+              id: 'weeklyDayTime',
+              type: 'short-input',
+              value: '',
+            },
+            monthlyDay: {
+              id: 'monthlyDay',
+              type: 'short-input',
+              value: '',
+            },
+            monthlyTime: {
+              id: 'monthlyTime',
+              type: 'short-input',
+              value: '',
+            },
+            cronExpression: {
+              id: 'cronExpression',
+              type: 'short-input',
+              value: '',
+            },
+            timezone: {
+              id: 'timezone',
+              type: 'dropdown',
+              value: 'UTC',
+            },
+          },
+          outputs: {
+            response: {
+              type: {
+                input: 'any',
+              },
+            },
+          },
+          enabled: true,
+          horizontalHandles: true,
+          isWide: false,
+          height: 95,
+        },
+      },
+      edges: [],
+      subflows: {},
+      variables: {},
+      metadata: {
+        version: '1.0.0',
+        createdAt: now.toISOString(),
+        updatedAt: now.toISOString(),
+      },
+    }
+
+    // Create the workflow and start block in a transaction
+    await db.transaction(async (tx) => {
+      // Create the workflow
+      await tx.insert(workflow).values({
+        id: workflowId,
+        userId: session.user.id,
+        workspaceId: workspaceId || null,
+        folderId: folderId || null,
+        name,
+        description,
+        state: initialState,
+        color,
+        lastSynced: now,
+        createdAt: now,
+        updatedAt: now,
+        isDeployed: false,
+        collaborators: [],
+        runCount: 0,
+        variables: {},
+        isPublished: false,
+        marketplaceData: null,
+      })
+
+      // Insert the start block into workflow_blocks table
+      await tx.insert(workflowBlocks).values({
+        id: starterId,
+        workflowId: workflowId,
+        type: 'starter',
+        name: 'Start',
+        positionX: '100',
+        positionY: '100',
+        enabled: true,
+        horizontalHandles: true,
+        isWide: false,
+        height: '95',
+        subBlocks: {
+          startWorkflow: {
+            id: 'startWorkflow',
+            type: 'dropdown',
+            value: 'manual',
+          },
+          webhookPath: {
+            id: 'webhookPath',
+            type: 'short-input',
+            value: '',
+          },
+          webhookSecret: {
+            id: 'webhookSecret',
+            type: 'short-input',
+            value: '',
+          },
+          scheduleType: {
+            id: 'scheduleType',
+            type: 'dropdown',
+            value: 'daily',
+          },
+          minutesInterval: {
+            id: 'minutesInterval',
+            type: 'short-input',
+            value: '',
+          },
+          minutesStartingAt: {
+            id: 'minutesStartingAt',
+            type: 'short-input',
+            value: '',
+          },
+          hourlyMinute: {
+            id: 'hourlyMinute',
+            type: 'short-input',
+            value: '',
+          },
+          dailyTime: {
+            id: 'dailyTime',
+            type: 'short-input',
+            value: '',
+          },
+          weeklyDay: {
+            id: 'weeklyDay',
+            type: 'dropdown',
+            value: 'MON',
+          },
+          weeklyDayTime: {
+            id: 'weeklyDayTime',
+            type: 'short-input',
+            value: '',
+          },
+          monthlyDay: {
+            id: 'monthlyDay',
+            type: 'short-input',
+            value: '',
+          },
+          monthlyTime: {
+            id: 'monthlyTime',
+            type: 'short-input',
+            value: '',
+          },
+          cronExpression: {
+            id: 'cronExpression',
+            type: 'short-input',
+            value: '',
+          },
+          timezone: {
+            id: 'timezone',
+            type: 'dropdown',
+            value: 'UTC',
+          },
+        },
+        outputs: {
+          response: {
+            type: {
+              input: 'any',
+            },
+          },
+        },
+        createdAt: now,
+        updatedAt: now,
+      })
+
+      logger.info(
+        `[${requestId}] Successfully created workflow ${workflowId} with start block in workflow_blocks table`
+      )
+    })
+
+    return NextResponse.json({
+      id: workflowId,
+      name,
+      description,
+      color,
+      workspaceId,
+      folderId,
+      createdAt: now,
+      updatedAt: now,
+    })
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      logger.warn(`[${requestId}] Invalid workflow creation data`, {
+        errors: error.errors,
+      })
+      return NextResponse.json(
+        { error: 'Invalid request data', details: error.errors },
+        { status: 400 }
+      )
+    }
+
+    logger.error(`[${requestId}] Error creating workflow`, error)
+    return NextResponse.json({ error: 'Failed to create workflow' }, { status: 500 })
+  }
+}
diff --git a/apps/sim/app/api/workflows/sync/route.ts b/apps/sim/app/api/workflows/sync/route.ts
index 49949a30540..3c7a25af0f2 100644
--- a/apps/sim/app/api/workflows/sync/route.ts
+++ b/apps/sim/app/api/workflows/sync/route.ts
@@ -1,55 +1,13 @@
+import crypto from 'crypto'
 import { and, eq, isNull } from 'drizzle-orm'
-import { type NextRequest, NextResponse } from 'next/server'
-import { z } from 'zod'
+import { NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
 import { createLogger } from '@/lib/logs/console-logger'
-import { saveWorkflowToNormalizedTables } from '@/lib/workflows/db-helpers'
 import { db } from '@/db'
 import { workflow, workspace, workspaceMember } from '@/db/schema'
 
 const logger = createLogger('WorkflowAPI')
 
-// Define marketplace data schema
-const MarketplaceDataSchema = z
-  .object({
-    id: z.string(),
-    status: z.enum(['owner', 'temp']),
-  })
-  .nullable()
-  .optional()
-
-// Schema for workflow data
-const WorkflowStateSchema = z.object({
-  blocks: z.record(z.any()),
-  edges: z.array(z.any()),
-  loops: z.record(z.any()).default({}),
-  parallels: z.record(z.any()).default({}),
-  lastSaved: z.number().optional(),
-  isDeployed: z.boolean().optional(),
-  deployedAt: z
-    .union([z.string(), z.date()])
-    .optional()
-    .transform((val) => (typeof val === 'string' ? new Date(val) : val)),
-  isPublished: z.boolean().optional(),
-  marketplaceData: MarketplaceDataSchema,
-})
-
-const WorkflowSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  description: z.string().optional(),
-  color: z.string().optional(),
-  state: WorkflowStateSchema,
-  marketplaceData: MarketplaceDataSchema,
-  workspaceId: z.string().optional(),
-  folderId: z.string().nullable().optional(),
-})
-
-const SyncPayloadSchema = z.object({
-  workflows: z.record(z.string(), WorkflowSchema),
-  workspaceId: z.string().optional(),
-})
-
 // Cache for workspace membership to reduce DB queries
 const workspaceMembershipCache = new Map<string, { role: string; expires: number }>()
 const CACHE_TTL = 60000 // 1 minute cache expiration
@@ -269,293 +227,7 @@ async function migrateOrphanedWorkflows(userId: string, workspaceId: string) {
   }
 }
 
-export async function POST(req: NextRequest) {
-  const requestId = crypto.randomUUID().slice(0, 8)
-  const startTime = Date.now()
-
-  try {
-    const session = await getSession()
-    if (!session?.user?.id) {
-      logger.warn(`[${requestId}] Unauthorized workflow sync attempt`)
-      return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
-    }
-
-    const body = await req.json()
-
-    try {
-      const { workflows: clientWorkflows, workspaceId } = SyncPayloadSchema.parse(body)
-
-      // CRITICAL SAFEGUARD: Prevent wiping out existing workflows
-      // If client is sending empty workflows object, first check if user has existing workflows
-      if (Object.keys(clientWorkflows).length === 0) {
-        let existingWorkflows
-
-        if (workspaceId) {
-          existingWorkflows = await db
-            .select({ id: workflow.id })
-            .from(workflow)
-            .where(eq(workflow.workspaceId, workspaceId))
-            .limit(1)
-        } else {
-          existingWorkflows = await db
-            .select({ id: workflow.id })
-            .from(workflow)
-            .where(eq(workflow.userId, session.user.id))
-            .limit(1)
-        }
-
-        // If user has existing workflows, but client sends empty, reject the sync
-        if (existingWorkflows.length > 0) {
-          logger.warn(
-            `[${requestId}] Prevented data loss: Client attempted to sync empty workflows while DB has workflows in workspace ${workspaceId || 'default'}`
-          )
-          return NextResponse.json(
-            {
-              error: 'Sync rejected to prevent data loss',
-              message: 'Client sent empty workflows, but user has existing workflows in database',
-            },
-            { status: 409 }
-          )
-        }
-      }
-
-      // Validate workspace membership and permissions
-      let userRole: string | null = null
-
-      if (workspaceId) {
-        const workspaceExists = await db
-          .select({ id: workspace.id })
-          .from(workspace)
-          .where(eq(workspace.id, workspaceId))
-          .then((rows) => rows.length > 0)
-
-        if (!workspaceExists) {
-          logger.warn(
-            `[${requestId}] Attempt to sync workflows to non-existent workspace: ${workspaceId}`
-          )
-          return NextResponse.json(
-            {
-              error: 'Workspace not found',
-              code: 'WORKSPACE_NOT_FOUND',
-            },
-            { status: 404 }
-          )
-        }
-
-        // Verify the user is a member of the workspace using our optimized function
-        userRole = await verifyWorkspaceMembership(session.user.id, workspaceId)
-
-        if (!userRole) {
-          logger.warn(
-            `[${requestId}] User ${session.user.id} attempted to sync to workspace ${workspaceId} without membership`
-          )
-          return NextResponse.json(
-            { error: 'Access denied to this workspace', code: 'WORKSPACE_ACCESS_DENIED' },
-            { status: 403 }
-          )
-        }
-      }
-
-      // Get all workflows for the workspace from the database
-      // If workspaceId is provided, only get workflows for that workspace
-      let dbWorkflows
-
-      if (workspaceId) {
-        dbWorkflows = await db.select().from(workflow).where(eq(workflow.workspaceId, workspaceId))
-      } else {
-        dbWorkflows = await db.select().from(workflow).where(eq(workflow.userId, session.user.id))
-      }
-
-      const now = new Date()
-      const operations: Promise<any>[] = []
-
-      // Create a map of DB workflows for easier lookup
-      const dbWorkflowMap = new Map(dbWorkflows.map((w) => [w.id, w]))
-      const processedIds = new Set<string>()
-
-      // Process client workflows
-      for (const [id, clientWorkflow] of Object.entries(clientWorkflows)) {
-        processedIds.add(id)
-        const dbWorkflow = dbWorkflowMap.get(id)
-
-        // Handle legacy published workflows migration (only if state is provided)
-        // If client workflow has isPublished but no marketplaceData, create marketplaceData with owner status
-        if (clientWorkflow.state?.isPublished && !clientWorkflow.marketplaceData) {
-          clientWorkflow.marketplaceData = { id: clientWorkflow.id, status: 'owner' }
-        }
-
-        // Ensure the workflow has the correct workspaceId
-        const effectiveWorkspaceId = clientWorkflow.workspaceId || workspaceId
-
-        // Save to normalized tables for all workflows (hybrid approach)
-        const normalizedResult = await saveWorkflowToNormalizedTables(id, {
-          blocks: clientWorkflow.state.blocks || {},
-          edges: clientWorkflow.state.edges || [],
-          loops: clientWorkflow.state.loops || {},
-          parallels: clientWorkflow.state.parallels || {},
-          lastSaved: clientWorkflow.state.lastSaved,
-          isDeployed: clientWorkflow.state.isDeployed,
-          deployedAt: clientWorkflow.state.deployedAt,
-          deploymentStatuses: (clientWorkflow.state as any).deploymentStatuses || {},
-          hasActiveSchedule: (clientWorkflow.state as any).hasActiveSchedule,
-          hasActiveWebhook: (clientWorkflow.state as any).hasActiveWebhook,
-        })
-
-        // Use the JSON blob from normalized save for compatibility, or fallback to original state
-        const stateToSave =
-          normalizedResult.success && normalizedResult.jsonBlob
-            ? normalizedResult.jsonBlob
-            : clientWorkflow.state
-
-        if (normalizedResult.success) {
-          logger.info(`[${requestId}] Saved workflow ${id} to normalized tables`)
-        } else {
-          logger.warn(
-            `[${requestId}] Failed to save workflow ${id} to normalized tables: ${normalizedResult.error}`
-          )
-        }
-
-        if (!dbWorkflow) {
-          // New workflow - create (state is required by schema)
-          operations.push(
-            db.insert(workflow).values({
-              id: clientWorkflow.id,
-              userId: session.user.id,
-              workspaceId: effectiveWorkspaceId,
-              folderId: clientWorkflow.folderId || null,
-              name: clientWorkflow.name,
-              description: clientWorkflow.description,
-              color: clientWorkflow.color,
-              state: stateToSave,
-              marketplaceData: clientWorkflow.marketplaceData || null,
-              // Include deployment status from client state
-              isDeployed: clientWorkflow.state.isDeployed || false,
-              deployedAt: clientWorkflow.state.deployedAt || null,
-              // deployedState is null for new workflows - only set during deployment
-              deployedState: null,
-              lastSynced: now,
-              createdAt: now,
-              updatedAt: now,
-            })
-          )
-        } else {
-          // Check if user has permission to update this workflow
-          const canUpdate =
-            dbWorkflow.userId === session.user.id ||
-            (workspaceId && (userRole === 'owner' || userRole === 'admin' || userRole === 'member'))
-
-          if (!canUpdate) {
-            logger.warn(
-              `[${requestId}] User ${session.user.id} attempted to update workflow ${id} without permission`
-            )
-            continue // Skip this workflow update and move to the next one
-          }
-
-          // For existing workflows, determine what needs updating
-          let needsUpdate = false
-          const updateData: any = {}
-
-          // Check metadata changes
-          if (dbWorkflow.name !== clientWorkflow.name) {
-            updateData.name = clientWorkflow.name
-            needsUpdate = true
-          }
-          if (dbWorkflow.description !== clientWorkflow.description) {
-            updateData.description = clientWorkflow.description
-            needsUpdate = true
-          }
-          if (dbWorkflow.color !== clientWorkflow.color) {
-            updateData.color = clientWorkflow.color
-            needsUpdate = true
-          }
-          if (dbWorkflow.workspaceId !== effectiveWorkspaceId) {
-            updateData.workspaceId = effectiveWorkspaceId
-            needsUpdate = true
-          }
-          if (dbWorkflow.folderId !== (clientWorkflow.folderId || null)) {
-            updateData.folderId = clientWorkflow.folderId || null
-            needsUpdate = true
-          }
-          if (
-            JSON.stringify(dbWorkflow.marketplaceData) !==
-            JSON.stringify(clientWorkflow.marketplaceData)
-          ) {
-            updateData.marketplaceData = clientWorkflow.marketplaceData || null
-            needsUpdate = true
-          }
-
-          // Always update state since we only sync the active workflow with valid state
-          if (JSON.stringify(dbWorkflow.state) !== JSON.stringify(stateToSave)) {
-            updateData.state = stateToSave
-            needsUpdate = true
-          }
-
-          // Check deployment status changes - ensure dual-write consistency
-          const clientIsDeployed = clientWorkflow.state.isDeployed || false
-          const clientDeployedAt = clientWorkflow.state.deployedAt || null
-
-          if (dbWorkflow.isDeployed !== clientIsDeployed) {
-            updateData.isDeployed = clientIsDeployed
-            needsUpdate = true
-          }
-
-          // Handle deployedAt comparison (convert to comparable format)
-          const dbDeployedAtTime = dbWorkflow.deployedAt
-            ? new Date(dbWorkflow.deployedAt).getTime()
-            : null
-          const clientDeployedAtTime = clientDeployedAt
-            ? new Date(clientDeployedAt).getTime()
-            : null
-
-          if (dbDeployedAtTime !== clientDeployedAtTime) {
-            updateData.deployedAt = clientDeployedAt
-            needsUpdate = true
-          }
-
-          // CRITICAL: Always preserve deployedState - it should only be modified by deploy/undeploy operations
-          // The sync operation should never touch deployedState to prevent data loss
-          // Note: We don't add deployedState to updateData because we want to preserve the existing value
-
-          if (needsUpdate) {
-            updateData.lastSynced = now
-            updateData.updatedAt = now
-
-            operations.push(db.update(workflow).set(updateData).where(eq(workflow.id, id)))
-          }
-        }
-      }
-
-      // NOTE: We don't delete workflows here since we're only syncing the active workflow
-      // Other workflows remain untouched in the database
-
-      // Execute all operations in parallel
-      await Promise.all(operations)
-
-      const elapsed = Date.now() - startTime
-
-      return NextResponse.json({
-        success: true,
-        stats: {
-          elapsed,
-          operations: operations.length,
-          workflows: Object.keys(clientWorkflows).length,
-        },
-      })
-    } catch (validationError) {
-      if (validationError instanceof z.ZodError) {
-        logger.warn(`[${requestId}] Invalid workflow data`, {
-          errors: validationError.errors,
-        })
-        return NextResponse.json(
-          { error: 'Invalid request data', details: validationError.errors },
-          { status: 400 }
-        )
-      }
-      throw validationError
-    }
-  } catch (error) {
-    const elapsed = Date.now() - startTime
-    logger.error(`[${requestId}] Workflow sync error after ${elapsed}ms`, error)
-    return NextResponse.json({ error: 'Workflow sync failed' }, { status: 500 })
-  }
-}
+// POST method removed - workflow operations now handled by:
+// - POST /api/workflows (create)
+// - DELETE /api/workflows/[id] (delete)
+// - Socket.IO collaborative operations (real-time updates)
diff --git a/apps/sim/app/api/workspaces/[id]/route.ts b/apps/sim/app/api/workspaces/[id]/route.ts
index 7c2ba26f247..32366141961 100644
--- a/apps/sim/app/api/workspaces/[id]/route.ts
+++ b/apps/sim/app/api/workspaces/[id]/route.ts
@@ -1,6 +1,17 @@
 import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
+import { createLogger } from '@/lib/logs/console-logger'
+import {
+  workflow,
+  workflowBlocks,
+  workflowEdges,
+  workflowSubflows,
+  workspaceMember,
+} from '@/db/schema'
+
+const logger = createLogger('WorkspaceByIdAPI')
+
 import { getUserEntityPermissions } from '@/lib/permissions/utils'
 import { db } from '@/db'
 import { permissions, workspace } from '@/db/schema'
@@ -111,20 +122,43 @@ export async function DELETE(
   }
 
   try {
-    // Use a transaction to ensure data consistency
+    logger.info(`Deleting workspace ${workspaceId} for user ${session.user.id}`)
+
+    // Delete workspace and all related data in a transaction
     await db.transaction(async (tx) => {
-      // 1. Delete all permissions associated with this workspace
+      // Get all workflows in this workspace
+      const workspaceWorkflows = await tx
+        .select({ id: workflow.id })
+        .from(workflow)
+        .where(eq(workflow.workspaceId, workspaceId))
+
+      // Delete all workflow-related data for each workflow
+      for (const wf of workspaceWorkflows) {
+        await tx.delete(workflowSubflows).where(eq(workflowSubflows.workflowId, wf.id))
+        await tx.delete(workflowEdges).where(eq(workflowEdges.workflowId, wf.id))
+        await tx.delete(workflowBlocks).where(eq(workflowBlocks.workflowId, wf.id))
+      }
+
+      // Delete all workflows in the workspace
+      await tx.delete(workflow).where(eq(workflow.workspaceId, workspaceId))
+
+      // Delete workspace members
+      await tx.delete(workspaceMember).where(eq(workspaceMember.workspaceId, workspaceId))
+
+      // Delete all permissions associated with this workspace
       await tx
         .delete(permissions)
         .where(and(eq(permissions.entityType, 'workspace'), eq(permissions.entityId, workspaceId)))
 
-      // 2. Delete workspace (cascade will handle members, workflows, etc.)
+      // Delete the workspace itself
       await tx.delete(workspace).where(eq(workspace.id, workspaceId))
+
+      logger.info(`Successfully deleted workspace ${workspaceId} and all related data`)
     })
 
     return NextResponse.json({ success: true })
   } catch (error) {
-    console.error('Error deleting workspace:', error)
+    logger.error(`Error deleting workspace ${workspaceId}:`, error)
     return NextResponse.json({ error: 'Failed to delete workspace' }, { status: 500 })
   }
 }
diff --git a/apps/sim/app/api/workspaces/route.ts b/apps/sim/app/api/workspaces/route.ts
index 310d9d309e4..e6aac33f5e1 100644
--- a/apps/sim/app/api/workspaces/route.ts
+++ b/apps/sim/app/api/workspaces/route.ts
@@ -1,8 +1,9 @@
+import crypto from 'crypto'
 import { and, desc, eq, isNull } from 'drizzle-orm'
 import { NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
 import { db } from '@/db'
-import { permissions, workflow, workspace, workspaceMember } from '@/db/schema'
+import { permissions, workflow, workflowBlocks, workspace, workspaceMember } from '@/db/schema'
 
 // Get all workspaces for the current user
 export async function GET() {
@@ -78,25 +79,175 @@ async function createDefaultWorkspace(userId: string, userName?: string | null)
 // Helper function to create a workspace
 async function createWorkspace(userId: string, name: string) {
   const workspaceId = crypto.randomUUID()
+  const workflowId = crypto.randomUUID()
+  const now = new Date()
 
-  // Create the workspace
-  await db.insert(workspace).values({
-    id: workspaceId,
-    name,
-    ownerId: userId,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-  })
+  // Create the workspace and initial workflow in a transaction
+  try {
+    await db.transaction(async (tx) => {
+      // Create the workspace
+      await tx.insert(workspace).values({
+        id: workspaceId,
+        name,
+        ownerId: userId,
+        createdAt: now,
+        updatedAt: now,
+      })
 
-  // Add the user as a member with owner role
-  await db.insert(workspaceMember).values({
-    id: crypto.randomUUID(),
-    workspaceId,
-    userId,
-    role: 'owner',
-    joinedAt: new Date(),
-    updatedAt: new Date(),
-  })
+      // Add the user as a member with owner role
+      await tx.insert(workspaceMember).values({
+        id: crypto.randomUUID(),
+        workspaceId,
+        userId,
+        role: 'owner',
+        joinedAt: now,
+        updatedAt: now,
+      })
+
+      // Create "Workflow 1" for the workspace with start block
+      const starterId = crypto.randomUUID()
+      const initialState = {
+        blocks: {
+          [starterId]: {
+            id: starterId,
+            type: 'starter',
+            name: 'Start',
+            position: { x: 100, y: 100 },
+            subBlocks: {
+              startWorkflow: {
+                id: 'startWorkflow',
+                type: 'dropdown',
+                value: 'manual',
+              },
+              webhookPath: {
+                id: 'webhookPath',
+                type: 'short-input',
+                value: '',
+              },
+              webhookSecret: {
+                id: 'webhookSecret',
+                type: 'short-input',
+                value: '',
+              },
+              scheduleType: {
+                id: 'scheduleType',
+                type: 'dropdown',
+                value: 'daily',
+              },
+              minutesInterval: {
+                id: 'minutesInterval',
+                type: 'short-input',
+                value: '',
+              },
+              minutesStartingAt: {
+                id: 'minutesStartingAt',
+                type: 'short-input',
+                value: '',
+              },
+            },
+            outputs: {
+              response: { type: { input: 'any' } },
+            },
+            enabled: true,
+            horizontalHandles: true,
+            isWide: false,
+            height: 95,
+          },
+        },
+        edges: [],
+        subflows: {},
+        variables: {},
+        metadata: {
+          version: '1.0.0',
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString(),
+        },
+      }
+
+      // Create the workflow
+      await tx.insert(workflow).values({
+        id: workflowId,
+        userId,
+        workspaceId,
+        folderId: null,
+        name: 'Workflow 1',
+        description: 'Your first workflow - start building here!',
+        state: initialState,
+        color: '#3972F6',
+        lastSynced: now,
+        createdAt: now,
+        updatedAt: now,
+        isDeployed: false,
+        collaborators: [],
+        runCount: 0,
+        variables: {},
+        isPublished: false,
+        marketplaceData: null,
+      })
+
+      // Insert the start block into workflow_blocks table
+      await tx.insert(workflowBlocks).values({
+        id: starterId,
+        workflowId: workflowId,
+        type: 'starter',
+        name: 'Start',
+        positionX: '100',
+        positionY: '100',
+        enabled: true,
+        horizontalHandles: true,
+        isWide: false,
+        height: '95',
+        subBlocks: {
+          startWorkflow: {
+            id: 'startWorkflow',
+            type: 'dropdown',
+            value: 'manual',
+          },
+          webhookPath: {
+            id: 'webhookPath',
+            type: 'short-input',
+            value: '',
+          },
+          webhookSecret: {
+            id: 'webhookSecret',
+            type: 'short-input',
+            value: '',
+          },
+          scheduleType: {
+            id: 'scheduleType',
+            type: 'dropdown',
+            value: 'daily',
+          },
+          minutesInterval: {
+            id: 'minutesInterval',
+            type: 'short-input',
+            value: '',
+          },
+          minutesStartingAt: {
+            id: 'minutesStartingAt',
+            type: 'short-input',
+            value: '',
+          },
+        },
+        outputs: {
+          response: {
+            type: {
+              input: 'any',
+            },
+          },
+        },
+        createdAt: now,
+        updatedAt: now,
+      })
+
+      console.log(
+        `✅ Created workspace ${workspaceId} with initial workflow ${workflowId} for user ${userId}`
+      )
+    })
+  } catch (error) {
+    console.error(`❌ Failed to create workspace ${workspaceId} with initial workflow:`, error)
+    throw error
+  }
 
   // Create default permissions for the workspace owner
   await db.insert(permissions).values({
@@ -114,8 +265,8 @@ async function createWorkspace(userId: string, name: string) {
     id: workspaceId,
     name,
     ownerId: userId,
-    createdAt: new Date(),
-    updatedAt: new Date(),
+    createdAt: now,
+    updatedAt: now,
     role: 'owner',
   }
 }
diff --git a/apps/sim/app/w/[id]/components/control-bar/components/user-avatar-stack/components/user-avatar/user-avatar.tsx b/apps/sim/app/w/[id]/components/control-bar/components/user-avatar-stack/components/user-avatar/user-avatar.tsx
new file mode 100644
index 00000000000..764b3fcc931
--- /dev/null
+++ b/apps/sim/app/w/[id]/components/control-bar/components/user-avatar-stack/components/user-avatar/user-avatar.tsx
@@ -0,0 +1,100 @@
+'use client'
+
+import { type CSSProperties, useMemo } from 'react'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+
+interface AvatarProps {
+  connectionId: number
+  name?: string
+  color?: string
+  tooltipContent?: React.ReactNode | null
+  size?: 'sm' | 'md' | 'lg'
+  index?: number // Position in stack for z-index
+}
+
+// Color palette inspired by the app's design
+const APP_COLORS = [
+  { from: '#4F46E5', to: '#7C3AED' }, // indigo to purple
+  { from: '#7C3AED', to: '#C026D3' }, // purple to fuchsia
+  { from: '#EC4899', to: '#F97316' }, // pink to orange
+  { from: '#14B8A6', to: '#10B981' }, // teal to emerald
+  { from: '#6366F1', to: '#8B5CF6' }, // indigo to violet
+  { from: '#F59E0B', to: '#F97316' }, // amber to orange
+]
+
+/**
+ * Generate a deterministic gradient based on a connection ID
+ */
+function generateGradient(connectionId: number): string {
+  // Use the connection ID to select a color pair from our palette
+  const colorPair = APP_COLORS[connectionId % APP_COLORS.length]
+
+  // Add a slight rotation to the gradient based on connection ID for variety
+  const rotation = (connectionId * 25) % 360
+
+  return `linear-gradient(${rotation}deg, ${colorPair.from}, ${colorPair.to})`
+}
+
+export function UserAvatar({
+  connectionId,
+  name,
+  color,
+  tooltipContent,
+  size = 'md',
+  index = 0,
+}: AvatarProps) {
+  // Generate a deterministic gradient for this user based on connection ID
+  // Or use the provided color if available
+  const backgroundStyle = useMemo(() => {
+    if (color) {
+      // If a color is provided, create a gradient with it
+      const baseColor = color
+      const lighterShade = color.startsWith('#')
+        ? `${color}dd` // Add transparency for a lighter shade effect
+        : color
+      const darkerShade = color.startsWith('#') ? color : color
+
+      return `linear-gradient(135deg, ${lighterShade}, ${darkerShade})`
+    }
+    // Otherwise, generate a gradient based on connectionId
+    return generateGradient(connectionId)
+  }, [connectionId, color])
+
+  // Determine avatar size
+  const sizeClass = {
+    sm: 'h-5 w-5 text-[10px]',
+    md: 'h-7 w-7 text-xs',
+    lg: 'h-9 w-9 text-sm',
+  }[size]
+
+  const initials = name ? name.charAt(0).toUpperCase() : '?'
+
+  const avatarElement = (
+    <div
+      className={`
+        ${sizeClass} flex flex-shrink-0 cursor-default items-center justify-center rounded-full border-2 border-white font-semibold text-white shadow-sm `}
+      style={
+        {
+          background: backgroundStyle,
+          zIndex: 10 - index, // Higher index = lower z-index for stacking effect
+        } as CSSProperties
+      }
+    >
+      {initials}
+    </div>
+  )
+
+  // If tooltip content is provided, wrap in tooltip
+  if (tooltipContent) {
+    return (
+      <Tooltip>
+        <TooltipTrigger asChild>{avatarElement}</TooltipTrigger>
+        <TooltipContent side='bottom' className='max-w-xs'>
+          {tooltipContent}
+        </TooltipContent>
+      </Tooltip>
+    )
+  }
+
+  return avatarElement
+}
diff --git a/apps/sim/app/w/[id]/components/control-bar/components/user-avatar-stack/user-avatar-stack.tsx b/apps/sim/app/w/[id]/components/control-bar/components/user-avatar-stack/user-avatar-stack.tsx
new file mode 100644
index 00000000000..b9b0973d3f5
--- /dev/null
+++ b/apps/sim/app/w/[id]/components/control-bar/components/user-avatar-stack/user-avatar-stack.tsx
@@ -0,0 +1,99 @@
+'use client'
+
+import { useMemo } from 'react'
+import { usePresence } from '../../../../hooks/use-presence'
+import { UserAvatar } from './components/user-avatar/user-avatar'
+
+interface User {
+  connectionId: number
+  name?: string
+  color?: string
+  info?: string
+}
+
+interface UserAvatarStackProps {
+  users?: User[]
+  maxVisible?: number
+  size?: 'sm' | 'md' | 'lg'
+  className?: string
+}
+
+export function UserAvatarStack({
+  users: propUsers,
+  maxVisible = 3,
+  size = 'md',
+  className = '',
+}: UserAvatarStackProps) {
+  // Use presence data if no users are provided via props
+  const { users: presenceUsers } = usePresence()
+  const users = propUsers || presenceUsers
+
+  // Memoize the processed users to avoid unnecessary re-renders
+  const { visibleUsers, overflowCount } = useMemo(() => {
+    if (users.length === 0) {
+      return { visibleUsers: [], overflowCount: 0 }
+    }
+
+    const visible = users.slice(0, maxVisible)
+    const overflow = Math.max(0, users.length - maxVisible)
+
+    return {
+      visibleUsers: visible,
+      overflowCount: overflow,
+    }
+  }, [users, maxVisible])
+
+  // Don't render anything if there are no users
+  if (users.length === 0) {
+    return null
+  }
+
+  // Determine spacing based on size
+  const spacingClass = {
+    sm: '-space-x-1',
+    md: '-space-x-1.5',
+    lg: '-space-x-2',
+  }[size]
+
+  return (
+    <div className={`flex items-center ${spacingClass} ${className}`}>
+      {/* Render visible user avatars */}
+      {visibleUsers.map((user, index) => (
+        <UserAvatar
+          key={user.connectionId}
+          connectionId={user.connectionId}
+          name={user.name}
+          color={user.color}
+          size={size}
+          index={index}
+          tooltipContent={
+            user.name ? (
+              <div className='text-center'>
+                <div className='font-medium'>{user.name}</div>
+                {user.info && <div className='mt-1 text-muted-foreground text-xs'>{user.info}</div>}
+              </div>
+            ) : null
+          }
+        />
+      ))}
+
+      {/* Render overflow indicator if there are more users */}
+      {overflowCount > 0 && (
+        <UserAvatar
+          connectionId={999} // Use a high number for consistent styling
+          name={`+${overflowCount}`}
+          size={size}
+          index={visibleUsers.length}
+          tooltipContent={
+            <div className='text-center'>
+              <div className='font-medium'>
+                {overflowCount} more user{overflowCount > 1 ? 's' : ''}
+              </div>
+              <div className='mt-1 text-muted-foreground text-xs'>{users.length} total online</div>
+            </div>
+          }
+        />
+      )}
+    </div>
+  )
+}
diff --git a/apps/sim/app/w/[id]/components/control-bar/control-bar.tsx b/apps/sim/app/w/[id]/components/control-bar/control-bar.tsx
index ec4c8b6b993..5da2dc64df6 100644
--- a/apps/sim/app/w/[id]/components/control-bar/control-bar.tsx
+++ b/apps/sim/app/w/[id]/components/control-bar/control-bar.tsx
@@ -47,7 +47,6 @@ import { usePanelStore } from '@/stores/panel/store'
 import { useGeneralStore } from '@/stores/settings/general/store'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
-import { mergeSubblockState } from '@/stores/workflows/utils'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 import type { WorkflowState } from '@/stores/workflows/workflow/types'
 import {
@@ -59,6 +58,7 @@ import { DeploymentControls } from './components/deployment-controls/deployment-
 import { HistoryDropdownItem } from './components/history-dropdown-item/history-dropdown-item'
 import { MarketplaceModal } from './components/marketplace-modal/marketplace-modal'
 import { NotificationDropdownItem } from './components/notification-dropdown-item/notification-dropdown-item'
+import { UserAvatarStack } from './components/user-avatar-stack/user-avatar-stack'
 
 const logger = createLogger('ControlBar')
 
@@ -73,11 +73,15 @@ let usageDataCache = {
 // Predefined run count options
 const RUN_COUNT_OPTIONS = [1, 5, 10, 25, 50, 100]
 
+interface ControlBarProps {
+  hasValidationErrors?: boolean
+}
+
 /**
  * Control bar for managing workflows - handles editing, deletion, deployment,
  * history, notifications and execution.
  */
-export function ControlBar() {
+export function ControlBar({ hasValidationErrors = false }: ControlBarProps) {
   const router = useRouter()
   const { data: session } = useSession()
 
@@ -156,19 +160,19 @@ export function ControlBar() {
     limit: number
   } | null>(null)
 
+  // Shared condition for keyboard shortcut and button disabled state
+  const isWorkflowBlocked = isExecuting || isMultiRunning || isCancelling || hasValidationErrors
+
   // Register keyboard shortcut for running workflow
-  useKeyboardShortcuts(
-    () => {
-      if (!isExecuting && !isMultiRunning && !isCancelling) {
-        if (isDebugModeEnabled) {
-          handleRunWorkflow()
-        } else {
-          handleMultipleRuns()
-        }
+  useKeyboardShortcuts(() => {
+    if (!isWorkflowBlocked) {
+      if (isDebugModeEnabled) {
+        handleRunWorkflow()
+      } else {
+        handleMultipleRuns()
       }
-    },
-    isExecuting || isMultiRunning || isCancelling
-  )
+    }
+  }, isWorkflowBlocked)
 
   // Get the marketplace data from the workflow registry if available
   const getMarketplaceData = () => {
@@ -287,28 +291,6 @@ export function ControlBar() {
     activeWorkflowId ? state.workflowValues[activeWorkflowId] : null
   )
 
-  /**
-   * Normalize blocks for semantic comparison - only compare what matters functionally
-   * Ignores: IDs, positions, dimensions, metadata that don't affect workflow logic
-   * Compares: type, name, subBlock values
-   */
-  const normalizeBlocksForComparison = (blocks: Record<string, any>) => {
-    if (!blocks) return []
-
-    return Object.values(blocks)
-      .map((block: any) => ({
-        type: block.type,
-        name: block.name,
-        subBlocks: block.subBlocks || {},
-      }))
-      .sort((a, b) => {
-        const typeA = a.type || ''
-        const typeB = b.type || ''
-        if (typeA !== typeB) return typeA.localeCompare(typeB)
-        return (a.name || '').localeCompare(b.name || '')
-      })
-  }
-
   useEffect(() => {
     if (!activeWorkflowId || !deployedState) {
       setChangeDetected(false)
@@ -319,20 +301,25 @@ export function ControlBar() {
       return
     }
 
-    const currentMergedState = mergeSubblockState(currentBlocks, activeWorkflowId)
-
-    const deployedBlocks = deployedState?.blocks
-    if (!deployedBlocks) {
-      setChangeDetected(false)
-      return
+    // Use the workflow status API to get accurate change detection
+    // This uses the same logic as the deployment API (reading from normalized tables)
+    const checkForChanges = async () => {
+      try {
+        const response = await fetch(`/api/workflows/${activeWorkflowId}/status`)
+        if (response.ok) {
+          const data = await response.json()
+          setChangeDetected(data.needsRedeployment || false)
+        } else {
+          logger.error('Failed to fetch workflow status:', response.status, response.statusText)
+          setChangeDetected(false)
+        }
+      } catch (error) {
+        logger.error('Error fetching workflow status:', error)
+        setChangeDetected(false)
+      }
     }
 
-    const normalizedCurrentBlocks = normalizeBlocksForComparison(currentMergedState)
-    const normalizedDeployedBlocks = normalizeBlocksForComparison(deployedBlocks)
-
-    const hasChanges =
-      JSON.stringify(normalizedCurrentBlocks) !== JSON.stringify(normalizedDeployedBlocks)
-    setChangeDetected(hasChanges)
+    checkForChanges()
   }, [activeWorkflowId, deployedState, currentBlocks, subBlockValues, isLoadingDeployedState])
 
   useEffect(() => {
@@ -583,16 +570,11 @@ export function ControlBar() {
   /**
    * Handle duplicating the current workflow
    */
-  const handleDuplicateWorkflow = () => {
+  const handleDuplicateWorkflow = async () => {
     if (!activeWorkflowId || !userPermissions.canEdit) return
 
-    // Duplicate the workflow and get the new ID
-    const newWorkflowId = duplicateWorkflow(activeWorkflowId)
-
-    if (newWorkflowId) {
-      // Navigate to the new workflow
-      router.push(`/w/${newWorkflowId}`)
-    }
+    // Duplicate the workflow - no automatic navigation
+    await duplicateWorkflow(activeWorkflowId)
   }
 
   /**
@@ -602,42 +584,45 @@ export function ControlBar() {
     const canEdit = userPermissions.canEdit
 
     return (
-      <div className='flex flex-col gap-[2px]'>
-        {isEditing ? (
-          <input
-            type='text'
-            value={editedName}
-            onChange={(e) => setEditedName(e.target.value)}
-            onBlur={handleNameSubmit}
-            onKeyDown={handleNameKeyDown}
-            className='w-[200px] border-none bg-transparent p-0 font-medium text-sm outline-none'
-          />
-        ) : (
-          <Tooltip>
-            <TooltipTrigger asChild>
-              <h2
-                className={cn(
-                  'w-fit font-medium text-sm',
-                  canEdit ? 'cursor-pointer hover:text-muted-foreground' : 'cursor-default'
-                )}
-                onClick={canEdit ? handleNameClick : undefined}
-              >
-                {activeWorkflowId ? workflows[activeWorkflowId]?.name : 'Workflow'}
-              </h2>
-            </TooltipTrigger>
-            {!canEdit && (
-              <TooltipContent>Admin permission required to rename workflows</TooltipContent>
-            )}
-          </Tooltip>
-        )}
-        {mounted && (
-          <p className='text-muted-foreground text-xs'>
-            Saved{' '}
-            {formatDistanceToNow(lastSaved || Date.now(), {
-              addSuffix: true,
-            })}
-          </p>
-        )}
+      <div className='flex items-center'>
+        <div className='flex flex-col gap-[2px]'>
+          {isEditing ? (
+            <input
+              type='text'
+              value={editedName}
+              onChange={(e) => setEditedName(e.target.value)}
+              onBlur={handleNameSubmit}
+              onKeyDown={handleNameKeyDown}
+              className='w-[200px] border-none bg-transparent p-0 font-medium text-sm outline-none'
+            />
+          ) : (
+            <Tooltip>
+              <TooltipTrigger asChild>
+                <h2
+                  className={cn(
+                    'w-fit font-medium text-sm',
+                    canEdit ? 'cursor-pointer hover:text-muted-foreground' : 'cursor-default'
+                  )}
+                  onClick={canEdit ? handleNameClick : undefined}
+                >
+                  {activeWorkflowId ? workflows[activeWorkflowId]?.name : 'Workflow'}
+                </h2>
+              </TooltipTrigger>
+              {!canEdit && (
+                <TooltipContent>Edit permissions required to rename workflows</TooltipContent>
+              )}
+            </Tooltip>
+          )}
+          {mounted && (
+            <p className='text-muted-foreground text-xs'>
+              Saved{' '}
+              {formatDistanceToNow(lastSaved || Date.now(), {
+                addSuffix: true,
+              })}
+            </p>
+          )}
+        </div>
+        <UserAvatarStack className='ml-3' />
       </div>
     )
   }
@@ -1058,8 +1043,7 @@ export function ControlBar() {
   const renderRunButton = () => {
     const canRun = userPermissions.canRead // Running only requires read permissions
     const isLoadingPermissions = userPermissions.isLoading
-    const isButtonDisabled =
-      isExecuting || isMultiRunning || isCancelling || (!canRun && !isLoadingPermissions)
+    const isButtonDisabled = isWorkflowBlocked || (!canRun && !isLoadingPermissions)
 
     return (
       <div className='flex items-center'>
@@ -1081,8 +1065,6 @@ export function ControlBar() {
           </div>
         )}
 
-        {renderDebugControls()}
-
         <div className='ml-1 flex'>
           {/* Main Run/Debug Button */}
           <Tooltip>
@@ -1133,7 +1115,15 @@ export function ControlBar() {
               </Button>
             </TooltipTrigger>
             <TooltipContent command={getKeyboardShortcutText('Enter', true)}>
-              {!canRun && !isLoadingPermissions ? (
+              {hasValidationErrors ? (
+                <div className='text-center'>
+                  <p className='font-medium text-destructive'>Workflow Has Errors</p>
+                  <p className='text-xs'>
+                    Nested subflows are not supported. Remove subflow blocks from inside other
+                    subflow blocks.
+                  </p>
+                </div>
+              ) : !canRun && !isLoadingPermissions ? (
                 'Read permission required to run workflows'
               ) : usageExceeded ? (
                 <div className='text-center'>
@@ -1143,6 +1133,8 @@ export function ControlBar() {
                     Upgrade your plan to continue.
                   </p>
                 </div>
+              ) : !canRun && !isLoadingPermissions ? (
+                'Read permissions required to run workflows'
               ) : (
                 <>
                   {isDebugModeEnabled
@@ -1154,6 +1146,7 @@ export function ControlBar() {
               )}
             </TooltipContent>
           </Tooltip>
+          {renderDebugControls()}
 
           {/* Dropdown Trigger - Only show when not in debug mode and not multi-running */}
           {!isDebugModeEnabled && !isMultiRunning && (
@@ -1198,7 +1191,6 @@ export function ControlBar() {
                   variant='outline'
                   size='icon'
                   onClick={() => {
-                    logger.info('Cancel button clicked - setting ref and state')
                     cancelFlagRef.current = true
                     setIsCancelling(true)
                   }}
diff --git a/apps/sim/app/w/[id]/components/loop-node/components/loop-badges.tsx b/apps/sim/app/w/[id]/components/loop-node/components/loop-badges.tsx
index 123a70a14c9..a73f9cc397d 100644
--- a/apps/sim/app/w/[id]/components/loop-node/components/loop-badges.tsx
+++ b/apps/sim/app/w/[id]/components/loop-node/components/loop-badges.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useRef, useState } from 'react'
 import { ChevronDown } from 'lucide-react'
 import { highlight, languages } from 'prismjs'
 import Editor from 'react-simple-code-editor'
@@ -7,6 +7,7 @@ import { Input } from '@/components/ui/input'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { checkTagTrigger, TagDropdown } from '@/components/ui/tag-dropdown'
 import { cn } from '@/lib/utils'
+import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 import 'prismjs/components/prism-javascript'
 import 'prismjs/themes/prism.css'
@@ -39,11 +40,25 @@ export function LoopBadges({ nodeId, data }: LoopBadgesProps) {
   // Check if this is preview mode
   const isPreview = data?.isPreview || false
 
-  // State
-  const [loopType, setLoopType] = useState(data?.loopType || 'for')
-  const [iterations, setIterations] = useState(data?.count || 5)
-  const [inputValue, setInputValue] = useState((data?.count || 5).toString())
-  const [editorValue, setEditorValue] = useState('')
+  // Get loop configuration from the workflow store (single source of truth)
+  const { loops } = useWorkflowStore()
+  const loopConfig = loops[nodeId]
+
+  // Use loop config as primary source, fallback to data for backward compatibility
+  const configIterations = loopConfig?.iterations ?? data?.count ?? 5
+  const configLoopType = loopConfig?.loopType ?? data?.loopType ?? 'for'
+  const configCollection = loopConfig?.forEachItems ?? data?.collection ?? ''
+
+  // Derive values directly from props - no useState needed for synchronized data
+  const loopType = configLoopType
+  const iterations = configIterations
+  const collectionString =
+    typeof configCollection === 'string' ? configCollection : JSON.stringify(configCollection) || ''
+
+  // Use actual values directly for display, temporary state only for active editing
+  const [tempInputValue, setTempInputValue] = useState<string | null>(null)
+  const inputValue = tempInputValue ?? iterations.toString()
+  const editorValue = collectionString
   const [typePopoverOpen, setTypePopoverOpen] = useState(false)
   const [configPopoverOpen, setConfigPopoverOpen] = useState(false)
   const [showTagDropdown, setShowTagDropdown] = useState(false)
@@ -51,62 +66,23 @@ export function LoopBadges({ nodeId, data }: LoopBadgesProps) {
   const textareaRef = useRef<HTMLTextAreaElement | null>(null)
   const editorContainerRef = useRef<HTMLDivElement>(null)
 
-  // Get store methods
-  const updateNodeData = useCallback(
-    (updates: Partial<LoopNodeData>) => {
-      if (isPreview) return // Don't update in preview mode
-
-      useWorkflowStore.setState((state) => ({
-        blocks: {
-          ...state.blocks,
-          [nodeId]: {
-            ...state.blocks[nodeId],
-            data: {
-              ...state.blocks[nodeId].data,
-              ...updates,
-            },
-          },
-        },
-      }))
-    },
-    [nodeId, isPreview]
-  )
-
-  const updateLoopType = useWorkflowStore((state) => state.updateLoopType)
-  const updateLoopCount = useWorkflowStore((state) => state.updateLoopCount)
-  const updateLoopCollection = useWorkflowStore((state) => state.updateLoopCollection)
-
-  // Initialize editor value from data when it changes
-  useEffect(() => {
-    if (data?.loopType && data.loopType !== loopType) {
-      setLoopType(data.loopType)
-    }
-    if (data?.count && data.count !== iterations) {
-      setIterations(data.count)
-      setInputValue(data.count.toString())
-    }
-
-    if (loopType === 'forEach' && data?.collection) {
-      if (typeof data.collection === 'string') {
-        setEditorValue(data.collection)
-      } else if (Array.isArray(data.collection) || typeof data.collection === 'object') {
-        setEditorValue(JSON.stringify(data.collection))
-      }
-    } else if (loopType === 'for') {
-      setEditorValue('')
-    }
-  }, [data?.loopType, data?.count, data?.collection, loopType, iterations])
+  // Get collaborative functions
+  const {
+    collaborativeUpdateLoopType,
+    collaborativeUpdateLoopCount,
+    collaborativeUpdateLoopCollection,
+  } = useCollaborativeWorkflow()
 
   // Handle loop type change
   const handleLoopTypeChange = useCallback(
     (newType: 'for' | 'forEach') => {
       if (isPreview) return // Don't allow changes in preview mode
 
-      setLoopType(newType)
-      updateLoopType(nodeId, newType)
+      // Update the collaborative state - this will cause the component to re-render with new derived values
+      collaborativeUpdateLoopType(nodeId, newType)
       setTypePopoverOpen(false)
     },
-    [nodeId, updateLoopType, isPreview]
+    [nodeId, collaborativeUpdateLoopType, isPreview]
   )
 
   // Handle iterations input change
@@ -118,9 +94,9 @@ export function LoopBadges({ nodeId, data }: LoopBadgesProps) {
       const numValue = Number.parseInt(sanitizedValue)
 
       if (!Number.isNaN(numValue)) {
-        setInputValue(Math.min(100, numValue).toString())
+        setTempInputValue(Math.min(100, numValue).toString())
       } else {
-        setInputValue(sanitizedValue)
+        setTempInputValue(sanitizedValue)
       }
     },
     [isPreview]
@@ -134,22 +110,21 @@ export function LoopBadges({ nodeId, data }: LoopBadgesProps) {
 
     if (!Number.isNaN(value)) {
       const newValue = Math.min(100, Math.max(1, value))
-      setIterations(newValue)
-      updateLoopCount(nodeId, newValue)
-      setInputValue(newValue.toString())
-    } else {
-      setInputValue(iterations.toString())
+      // Update the collaborative state - this will cause iterations to be derived from props
+      collaborativeUpdateLoopCount(nodeId, newValue)
     }
+    // Clear temporary input state to show the actual value
+    setTempInputValue(null)
     setConfigPopoverOpen(false)
-  }, [inputValue, iterations, nodeId, updateLoopCount, isPreview])
+  }, [inputValue, nodeId, collaborativeUpdateLoopCount, isPreview])
 
   // Handle editor change with tag dropdown support
   const handleEditorChange = useCallback(
     (value: string) => {
       if (isPreview) return // Don't allow changes in preview mode
 
-      setEditorValue(value)
-      updateLoopCollection(nodeId, value)
+      // Update collaborative state directly - no local state needed
+      collaborativeUpdateLoopCollection(nodeId, value)
 
       // Get the textarea element from the editor
       const textarea = editorContainerRef.current?.querySelector('textarea')
@@ -163,7 +138,7 @@ export function LoopBadges({ nodeId, data }: LoopBadgesProps) {
         setShowTagDropdown(triggerCheck.show)
       }
     },
-    [nodeId, updateLoopCollection, isPreview]
+    [nodeId, collaborativeUpdateLoopCollection, isPreview]
   )
 
   // Handle tag selection
@@ -171,8 +146,8 @@ export function LoopBadges({ nodeId, data }: LoopBadgesProps) {
     (newValue: string) => {
       if (isPreview) return // Don't allow changes in preview mode
 
-      setEditorValue(newValue)
-      updateLoopCollection(nodeId, newValue)
+      // Update collaborative state directly - no local state needed
+      collaborativeUpdateLoopCollection(nodeId, newValue)
       setShowTagDropdown(false)
 
       // Focus back on the editor after a short delay
@@ -183,7 +158,7 @@ export function LoopBadges({ nodeId, data }: LoopBadgesProps) {
         }
       }, 0)
     },
-    [nodeId, updateLoopCollection, isPreview]
+    [nodeId, collaborativeUpdateLoopCollection, isPreview]
   )
 
   return (
diff --git a/apps/sim/app/w/[id]/components/loop-node/loop-node.tsx b/apps/sim/app/w/[id]/components/loop-node/loop-node.tsx
index d657fac658b..0131e04b792 100644
--- a/apps/sim/app/w/[id]/components/loop-node/loop-node.tsx
+++ b/apps/sim/app/w/[id]/components/loop-node/loop-node.tsx
@@ -6,7 +6,7 @@ import { StartIcon } from '@/components/icons'
 import { Button } from '@/components/ui/button'
 import { Card } from '@/components/ui/card'
 import { cn } from '@/lib/utils'
-import { useWorkflowStore } from '@/stores/workflows/workflow/store'
+import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { LoopBadges } from './components/loop-badges'
 
 // Add these styles to your existing global CSS file or create a separate CSS module
@@ -69,7 +69,7 @@ const LoopNodeStyles: React.FC = () => {
 
 export const LoopNodeComponent = memo(({ data, selected, id }: NodeProps) => {
   const { getNodes } = useReactFlow()
-  const removeBlock = useWorkflowStore((state) => state.removeBlock)
+  const { collaborativeRemoveBlock } = useCollaborativeWorkflow()
   const blockRef = useRef<HTMLDivElement>(null)
 
   // Check if this is preview mode
@@ -123,7 +123,8 @@ export const LoopNodeComponent = memo(({ data, selected, id }: NodeProps) => {
             'z-[20]',
             data?.state === 'valid',
             nestingLevel > 0 &&
-              `border border-[0.5px] ${nestingLevel % 2 === 0 ? 'border-slate-300/60' : 'border-slate-400/60'}`
+              `border border-[0.5px] ${nestingLevel % 2 === 0 ? 'border-slate-300/60' : 'border-slate-400/60'}`,
+            data?.hasNestedError && 'border-2 border-red-500 bg-red-50/50'
           )}
           style={{
             width: data.width || 500,
@@ -170,7 +171,7 @@ export const LoopNodeComponent = memo(({ data, selected, id }: NodeProps) => {
                 size='sm'
                 onClick={(e) => {
                   e.stopPropagation()
-                  removeBlock(id)
+                  collaborativeRemoveBlock(id)
                 }}
                 className='absolute top-2 right-2 z-20 text-gray-500 opacity-0 transition-opacity duration-200 hover:text-red-600 group-hover:opacity-100'
                 style={{ pointerEvents: 'auto' }}
diff --git a/apps/sim/app/w/[id]/components/parallel-node/components/parallel-badges.tsx b/apps/sim/app/w/[id]/components/parallel-node/components/parallel-badges.tsx
index 9b95a077196..5b1604e09ce 100644
--- a/apps/sim/app/w/[id]/components/parallel-node/components/parallel-badges.tsx
+++ b/apps/sim/app/w/[id]/components/parallel-node/components/parallel-badges.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState } from 'react'
+import { useCallback, useRef, useState } from 'react'
 import { ChevronDown } from 'lucide-react'
 import { highlight, languages } from 'prismjs'
 import Editor from 'react-simple-code-editor'
@@ -7,6 +7,7 @@ import { Input } from '@/components/ui/input'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
 import { checkTagTrigger, TagDropdown } from '@/components/ui/tag-dropdown'
 import { cn } from '@/lib/utils'
+import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 import 'prismjs/components/prism-javascript'
 import 'prismjs/themes/prism.css'
@@ -39,13 +40,29 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
   // Check if this is preview mode
   const isPreview = data?.isPreview || false
 
-  // State
-  const [parallelType, setParallelType] = useState<'count' | 'collection'>(
-    data?.parallelType || 'collection'
-  )
-  const [iterations, setIterations] = useState(data?.count || 5)
-  const [inputValue, setInputValue] = useState((data?.count || 5).toString())
-  const [editorValue, setEditorValue] = useState('')
+  // Get parallel configuration from the workflow store (single source of truth)
+  const { parallels } = useWorkflowStore()
+  const parallelConfig = parallels[nodeId]
+
+  // Use parallel config as primary source, fallback to data for backward compatibility
+  const configCount = parallelConfig?.count ?? data?.count ?? 5
+  const configDistribution = parallelConfig?.distribution ?? data?.collection ?? ''
+  // For parallel type, use the block's parallelType data property as the source of truth
+  // Don't infer it from whether distribution exists, as that causes unwanted switching
+  const configParallelType = data?.parallelType || 'collection'
+
+  // Derive values directly from props - no useState needed for synchronized data
+  const parallelType = configParallelType
+  const iterations = configCount
+  const distributionString =
+    typeof configDistribution === 'string'
+      ? configDistribution
+      : JSON.stringify(configDistribution) || ''
+
+  // Use actual values directly for display, temporary state only for active editing
+  const [tempInputValue, setTempInputValue] = useState<string | null>(null)
+  const inputValue = tempInputValue ?? iterations.toString()
+  const editorValue = distributionString
   const [typePopoverOpen, setTypePopoverOpen] = useState(false)
   const [configPopoverOpen, setConfigPopoverOpen] = useState(false)
   const [showTagDropdown, setShowTagDropdown] = useState(false)
@@ -53,65 +70,32 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
   const editorContainerRef = useRef<HTMLDivElement>(null)
   const textareaRef = useRef<HTMLTextAreaElement | null>(null)
 
-  // Get store methods
-  const updateParallelCount = useWorkflowStore((state) => state.updateParallelCount)
-  const updateParallelCollection = useWorkflowStore((state) => state.updateParallelCollection)
-
-  // Update node data to include parallel type
-  const updateNodeData = useCallback(
-    (updates: Partial<ParallelNodeData>) => {
-      if (isPreview) return // Don't update in preview mode
-
-      useWorkflowStore.setState((state) => ({
-        blocks: {
-          ...state.blocks,
-          [nodeId]: {
-            ...state.blocks[nodeId],
-            data: {
-              ...state.blocks[nodeId].data,
-              ...updates,
-            },
-          },
-        },
-      }))
-    },
-    [nodeId, isPreview]
-  )
-
-  // Initialize state from data when it changes
-  useEffect(() => {
-    if (data?.parallelType && data.parallelType !== parallelType) {
-      setParallelType(data.parallelType)
-    }
-    if (data?.count && data.count !== iterations) {
-      setIterations(data.count)
-      setInputValue(data.count.toString())
-    }
-
-    if (data?.collection) {
-      if (typeof data.collection === 'string') {
-        setEditorValue(data.collection)
-      } else if (Array.isArray(data.collection) || typeof data.collection === 'object') {
-        setEditorValue(JSON.stringify(data.collection))
-      }
-    }
-  }, [data?.parallelType, data?.count, data?.collection, parallelType, iterations])
+  // Get collaborative functions
+  const {
+    collaborativeUpdateParallelCount,
+    collaborativeUpdateParallelCollection,
+    collaborativeUpdateParallelType,
+  } = useCollaborativeWorkflow()
 
   // Handle parallel type change
   const handleParallelTypeChange = useCallback(
     (newType: 'count' | 'collection') => {
       if (isPreview) return // Don't allow changes in preview mode
 
-      setParallelType(newType)
-      updateNodeData({ parallelType: newType })
+      // Update the parallel type using collaborative function - this will persist to database
+      collaborativeUpdateParallelType(nodeId, newType)
 
       // Reset values based on type
       if (newType === 'count') {
-        updateParallelCollection(nodeId, '')
-        updateParallelCount(nodeId, iterations)
+        collaborativeUpdateParallelCollection(nodeId, '')
+        collaborativeUpdateParallelCount(nodeId, iterations)
       } else {
-        updateParallelCount(nodeId, 1)
-        updateParallelCollection(nodeId, editorValue || '[]')
+        collaborativeUpdateParallelCount(nodeId, 1)
+        const collectionValue =
+          typeof editorValue === 'string'
+            ? editorValue || '[]'
+            : JSON.stringify(editorValue) || '[]'
+        collaborativeUpdateParallelCollection(nodeId, collectionValue)
       }
 
       setTypePopoverOpen(false)
@@ -120,9 +104,9 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
       nodeId,
       iterations,
       editorValue,
-      updateNodeData,
-      updateParallelCount,
-      updateParallelCollection,
+      collaborativeUpdateParallelCount,
+      collaborativeUpdateParallelCollection,
+      collaborativeUpdateParallelType,
       isPreview,
     ]
   )
@@ -136,9 +120,9 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
       const numValue = Number.parseInt(sanitizedValue)
 
       if (!Number.isNaN(numValue)) {
-        setInputValue(Math.min(20, numValue).toString())
+        setTempInputValue(Math.min(20, numValue).toString())
       } else {
-        setInputValue(sanitizedValue)
+        setTempInputValue(sanitizedValue)
       }
     },
     [isPreview]
@@ -152,22 +136,21 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
 
     if (!Number.isNaN(value)) {
       const newValue = Math.min(20, Math.max(1, value))
-      setIterations(newValue)
-      updateParallelCount(nodeId, newValue)
-      setInputValue(newValue.toString())
-    } else {
-      setInputValue(iterations.toString())
+      // Update the collaborative state - this will cause iterations to be derived from props
+      collaborativeUpdateParallelCount(nodeId, newValue)
     }
+    // Clear temporary input state to show the actual value
+    setTempInputValue(null)
     setConfigPopoverOpen(false)
-  }, [inputValue, iterations, nodeId, updateParallelCount, isPreview])
+  }, [inputValue, nodeId, collaborativeUpdateParallelCount, isPreview])
 
   // Handle editor change and check for tag trigger
   const handleEditorChange = useCallback(
     (value: string) => {
       if (isPreview) return // Don't allow changes in preview mode
 
-      setEditorValue(value)
-      updateParallelCollection(nodeId, value)
+      // Update collaborative state directly - no local state needed
+      collaborativeUpdateParallelCollection(nodeId, value)
 
       // Get the textarea element and cursor position
       const textarea = editorContainerRef.current?.querySelector('textarea')
@@ -181,7 +164,7 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
         setShowTagDropdown(tagTrigger.show)
       }
     },
-    [nodeId, updateParallelCollection, isPreview]
+    [nodeId, collaborativeUpdateParallelCollection, isPreview]
   )
 
   // Handle tag selection
@@ -189,8 +172,8 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
     (newValue: string) => {
       if (isPreview) return // Don't allow changes in preview mode
 
-      setEditorValue(newValue)
-      updateParallelCollection(nodeId, newValue)
+      // Update collaborative state directly - no local state needed
+      collaborativeUpdateParallelCollection(nodeId, newValue)
       setShowTagDropdown(false)
 
       // Focus back on the editor after selection
@@ -201,7 +184,7 @@ export function ParallelBadges({ nodeId, data }: ParallelBadgesProps) {
         }
       }, 0)
     },
-    [nodeId, updateParallelCollection, isPreview]
+    [nodeId, collaborativeUpdateParallelCollection, isPreview]
   )
 
   // Handle key events
diff --git a/apps/sim/app/w/[id]/components/parallel-node/parallel-node.tsx b/apps/sim/app/w/[id]/components/parallel-node/parallel-node.tsx
index 299a75acaed..688296190d2 100644
--- a/apps/sim/app/w/[id]/components/parallel-node/parallel-node.tsx
+++ b/apps/sim/app/w/[id]/components/parallel-node/parallel-node.tsx
@@ -6,7 +6,7 @@ import { StartIcon } from '@/components/icons'
 import { Button } from '@/components/ui/button'
 import { Card } from '@/components/ui/card'
 import { cn } from '@/lib/utils'
-import { useWorkflowStore } from '@/stores/workflows/workflow/store'
+import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { ParallelBadges } from './components/parallel-badges'
 
 const ParallelNodeStyles: React.FC = () => {
@@ -86,6 +86,7 @@ const ParallelNodeStyles: React.FC = () => {
 
 export const ParallelNodeComponent = memo(({ data, selected, id }: NodeProps) => {
   const { getNodes } = useReactFlow()
+  const { collaborativeRemoveBlock } = useCollaborativeWorkflow()
   const blockRef = useRef<HTMLDivElement>(null)
 
   // Check if this is preview mode
@@ -140,7 +141,8 @@ export const ParallelNodeComponent = memo(({ data, selected, id }: NodeProps) =>
             'z-[20]',
             data?.state === 'valid',
             nestingLevel > 0 &&
-              `border border-[0.5px] ${nestingLevel % 2 === 0 ? 'border-slate-300/60' : 'border-slate-400/60'}`
+              `border border-[0.5px] ${nestingLevel % 2 === 0 ? 'border-slate-300/60' : 'border-slate-400/60'}`,
+            data?.hasNestedError && 'border-2 border-red-500 bg-red-50/50'
           )}
           style={{
             width: data.width || 500,
@@ -187,7 +189,7 @@ export const ParallelNodeComponent = memo(({ data, selected, id }: NodeProps) =>
                 size='sm'
                 onClick={(e) => {
                   e.stopPropagation()
-                  useWorkflowStore.getState().removeBlock(id)
+                  collaborativeRemoveBlock(id)
                 }}
                 className='absolute top-2 right-2 z-20 text-gray-500 opacity-0 transition-opacity duration-200 hover:text-red-600 group-hover:opacity-100'
                 style={{ pointerEvents: 'auto' }}
diff --git a/apps/sim/app/w/[id]/components/workflow-block/components/action-bar/action-bar.tsx b/apps/sim/app/w/[id]/components/workflow-block/components/action-bar/action-bar.tsx
index aa0d6ac2e34..7f926ef4fa0 100644
--- a/apps/sim/app/w/[id]/components/workflow-block/components/action-bar/action-bar.tsx
+++ b/apps/sim/app/w/[id]/components/workflow-block/components/action-bar/action-bar.tsx
@@ -2,6 +2,7 @@ import { ArrowLeftRight, ArrowUpDown, Circle, CircleOff, Copy, Trash2 } from 'lu
 import { Button } from '@/components/ui/button'
 import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
 import { cn } from '@/lib/utils'
+import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
 interface ActionBarProps {
@@ -11,7 +12,7 @@ interface ActionBarProps {
 }
 
 export function ActionBar({ blockId, blockType, disabled = false }: ActionBarProps) {
-  const removeBlock = useWorkflowStore((state) => state.removeBlock)
+  const { collaborativeRemoveBlock } = useCollaborativeWorkflow()
   const toggleBlockEnabled = useWorkflowStore((state) => state.toggleBlockEnabled)
   const toggleBlockHandles = useWorkflowStore((state) => state.toggleBlockHandles)
   const duplicateBlock = useWorkflowStore((state) => state.duplicateBlock)
@@ -125,12 +126,12 @@ export function ActionBar({ blockId, blockType, disabled = false }: ActionBarPro
               size='sm'
               onClick={() => {
                 if (!disabled) {
-                  removeBlock(blockId)
+                  collaborativeRemoveBlock(blockId)
                 }
               }}
               className={cn(
                 'text-gray-500 hover:text-red-600',
-                disabled && 'cursor-not-allowed opacity-50 hover:text-gray-500'
+                disabled && 'cursor-not-allowed opacity-50'
               )}
               disabled={disabled}
             >
diff --git a/apps/sim/app/w/[id]/components/workflow-block/components/sub-block/hooks/use-sub-block-value.ts b/apps/sim/app/w/[id]/components/workflow-block/components/sub-block/hooks/use-sub-block-value.ts
index 5f287442766..3da6d0b7ea2 100644
--- a/apps/sim/app/w/[id]/components/workflow-block/components/sub-block/hooks/use-sub-block-value.ts
+++ b/apps/sim/app/w/[id]/components/workflow-block/components/sub-block/hooks/use-sub-block-value.ts
@@ -5,6 +5,18 @@ import { useGeneralStore } from '@/stores/settings/general/store'
 import { useSubBlockStore } from '@/stores/workflows/subblock/store'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
+// Helper function to dispatch collaborative subblock updates
+const dispatchSubblockUpdate = (blockId: string, subBlockId: string, value: any) => {
+  const event = new CustomEvent('update-subblock-value', {
+    detail: {
+      blockId,
+      subBlockId,
+      value,
+    },
+  })
+  window.dispatchEvent(event)
+}
+
 /**
  * Helper to handle API key auto-fill for provider-based blocks
  * Used for agent, router, evaluator, and any other blocks that use LLM providers
@@ -37,12 +49,12 @@ function handleProviderBasedApiKey(
   if (savedValue && savedValue !== '' && isAutoFillEnabled) {
     // Only update if the current value is different to avoid unnecessary updates
     if (storeValue !== savedValue) {
-      subBlockStore.setValue(blockId, subBlockId, savedValue)
+      dispatchSubblockUpdate(blockId, subBlockId, savedValue)
     }
   } else if (isModelChange && (!storeValue || storeValue === '')) {
     // Only clear the field when switching models AND the field is already empty
     // Don't clear existing user-entered values on initial load
-    subBlockStore.setValue(blockId, subBlockId, '')
+    dispatchSubblockUpdate(blockId, subBlockId, '')
   }
   // If no saved value and this is initial load, preserve existing value
 }
@@ -67,7 +79,7 @@ function handleStandardBlockApiKey(
 
     if (savedValue && savedValue !== '' && savedValue !== storeValue) {
       // Auto-fill the API key from the param store
-      subBlockStore.setValue(blockId, subBlockId, savedValue)
+      dispatchSubblockUpdate(blockId, subBlockId, savedValue)
     }
   }
   // Handle environment variable references
@@ -84,7 +96,7 @@ function handleStandardBlockApiKey(
       // If we got a replacement or null, update the field
       if (currentValue) {
         // Replacement found - update to new reference
-        subBlockStore.setValue(blockId, subBlockId, currentValue)
+        dispatchSubblockUpdate(blockId, subBlockId, currentValue)
       }
     }
   }
@@ -216,10 +228,19 @@ export function useSubBlockValue<T = any>(
           storeApiKeyValue(blockId, blockType, modelValue, newValue, storeValue)
         }
 
-        // Update the subblock store with the new value
-        // The store's setValue method will now trigger the debounced sync automatically
+        // Update the subblock store directly
         useSubBlockStore.getState().setValue(blockId, subBlockId, valueCopy)
 
+        // Dispatch event to trigger socket emission only (not store update)
+        const event = new CustomEvent('update-subblock-value', {
+          detail: {
+            blockId,
+            subBlockId,
+            value: valueCopy,
+          },
+        })
+        window.dispatchEvent(event)
+
         if (triggerWorkflowUpdate) {
           useWorkflowStore.getState().triggerUpdate()
         }
@@ -274,7 +295,7 @@ export function useSubBlockValue<T = any>(
         handleProviderBasedApiKey(blockId, subBlockId, modelValue, storeValue, true)
       } else {
         // If no model is selected, clear the API key field
-        useSubBlockStore.getState().setValue(blockId, subBlockId, '')
+        dispatchSubblockUpdate(blockId, subBlockId, '')
       }
     }
   }, [
@@ -297,5 +318,5 @@ export function useSubBlockValue<T = any>(
     }
   }, [storeValue, initialValue])
 
-  return [valueRef.current as T | null, setValue] as const
+  return [storeValue !== undefined ? storeValue : initialValue, setValue] as const
 }
diff --git a/apps/sim/app/w/[id]/hooks/use-presence.ts b/apps/sim/app/w/[id]/hooks/use-presence.ts
new file mode 100644
index 00000000000..3b86676e64f
--- /dev/null
+++ b/apps/sim/app/w/[id]/hooks/use-presence.ts
@@ -0,0 +1,42 @@
+'use client'
+
+import { useMemo } from 'react'
+import { useSocket } from '@/contexts/socket-context'
+
+interface PresenceUser {
+  connectionId: number
+  name?: string
+  color?: string
+  info?: string
+}
+
+interface UsePresenceReturn {
+  users: PresenceUser[]
+  currentUser: PresenceUser | null
+  isConnected: boolean
+}
+
+/**
+ * Hook for managing user presence in collaborative workflows using Socket.IO
+ * Uses the existing Socket context to get real presence data
+ */
+export function usePresence(): UsePresenceReturn {
+  const { presenceUsers, isConnected } = useSocket()
+
+  const users = useMemo(() => {
+    return presenceUsers.map((user, index) => ({
+      connectionId: user.socketId
+        ? Math.abs(user.socketId.split('').reduce((a, b) => a + b.charCodeAt(0), 0))
+        : index + 1,
+      name: user.userName,
+      color: undefined, // Let the avatar component generate colors
+      info: user.selection?.type ? `Editing ${user.selection.type}` : undefined,
+    }))
+  }, [presenceUsers])
+
+  return {
+    users,
+    currentUser: null,
+    isConnected,
+  }
+}
diff --git a/apps/sim/app/w/[id]/workflow.tsx b/apps/sim/app/w/[id]/workflow.tsx
index e5a492e05e1..e656b3fb1eb 100644
--- a/apps/sim/app/w/[id]/workflow.tsx
+++ b/apps/sim/app/w/[id]/workflow.tsx
@@ -18,14 +18,16 @@ import { NotificationList } from '@/app/w/[id]/components/notifications/notifica
 import { ParallelNodeComponent } from '@/app/w/[id]/components/parallel-node/parallel-node'
 import { useUserPermissionsContext } from '@/app/w/components/providers/workspace-permissions-provider'
 import { getBlock } from '@/blocks'
+import { useSocket } from '@/contexts/socket-context'
+import { useCollaborativeWorkflow } from '@/hooks/use-collaborative-workflow'
+import { useWorkspacePermissions } from '@/hooks/use-workspace-permissions'
 import { useExecutionStore } from '@/stores/execution/store'
 import { useNotificationStore } from '@/stores/notifications/store'
 import { useVariablesStore } from '@/stores/panel/variables/store'
 import { useGeneralStore } from '@/stores/settings/general/store'
 import { useSidebarStore } from '@/stores/sidebar/store'
-import { initializeSyncManagers } from '@/stores/sync-registry'
+// Removed sync manager import - Socket.IO handles real-time sync
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
-import { useSubBlockStore } from '@/stores/workflows/subblock/store'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 import { ControlBar } from './components/control-bar/control-bar'
 import { ErrorBoundary } from './components/error/index'
@@ -82,6 +84,8 @@ const WorkflowContent = React.memo(() => {
   // State for tracking node dragging
   const [draggedNodeId, setDraggedNodeId] = useState<string | null>(null)
   const [potentialParentId, setPotentialParentId] = useState<string | null>(null)
+  // State for tracking validation errors
+  const [nestedSubflowErrors, setNestedSubflowErrors] = useState<Set<string>>(new Set())
   // Enhanced edge selection with parent context and unique identifier
   const [selectedEdgeInfo, setSelectedEdgeInfo] = useState<SelectedEdgeInfo | null>(null)
 
@@ -92,36 +96,34 @@ const WorkflowContent = React.memo(() => {
 
   // Get workspace ID from current workflow
   const workflowId = params.id as string
-  const {
-    workflows,
-    activeWorkflowId,
-    isLoading,
-    setActiveWorkflow,
-    createWorkflow,
-    removeWorkflow,
-    updateWorkflow,
-    duplicateWorkflow,
-  } = useWorkflowRegistry()
+  const { workflows, activeWorkflowId, isLoading, setActiveWorkflow, createWorkflow } =
+    useWorkflowRegistry()
 
+  const { blocks, edges, updateNodeDimensions } = useWorkflowStore()
+  // Use collaborative operations for real-time sync
   const currentWorkflow = useMemo(() => workflows[workflowId], [workflows, workflowId])
   const workspaceId = currentWorkflow?.workspaceId
 
   // User permissions - get current user's specific permissions from context
   const userPermissions = useUserPermissionsContext()
 
+  // Workspace permissions - get all users and their permissions for this workspace
+  const { permissions: workspacePermissions, error: permissionsError } = useWorkspacePermissions(
+    workspaceId || null
+  )
+
   // Store access
   const {
-    blocks,
-    edges,
-    addBlock,
-    updateNodeDimensions,
-    updateBlockPosition,
-    addEdge,
-    removeEdge,
-    updateParentId,
-    removeBlock,
-  } = useWorkflowStore()
-  const { setValue: setSubBlockValue } = useSubBlockStore()
+    collaborativeAddBlock: addBlock,
+    collaborativeAddEdge: addEdge,
+    collaborativeRemoveEdge: removeEdge,
+    collaborativeUpdateBlockPosition: updateBlockPosition,
+    collaborativeUpdateParentId: updateParentId,
+    isConnected,
+    currentWorkflowId,
+    joinWorkflow,
+  } = useCollaborativeWorkflow()
+  const { emitSubblockUpdate } = useSocket()
   const { markAllAsRead } = useNotificationStore()
   const { resetLoaded: resetVariablesLoaded } = useVariablesStore()
 
@@ -130,6 +132,53 @@ const WorkflowContent = React.memo(() => {
   const { isDebugModeEnabled } = useGeneralStore()
   const [dragStartParentId, setDragStartParentId] = useState<string | null>(null)
 
+  // Helper function to validate workflow for nested subflows
+  const validateNestedSubflows = useCallback(() => {
+    const errors = new Set<string>()
+
+    Object.entries(blocks).forEach(([blockId, block]) => {
+      // Check if this is a subflow block (loop or parallel)
+      if (block.type === 'loop' || block.type === 'parallel') {
+        // Check if it has a parent that is also a subflow block
+        const parentId = block.data?.parentId
+        if (parentId) {
+          const parentBlock = blocks[parentId]
+          if (parentBlock && (parentBlock.type === 'loop' || parentBlock.type === 'parallel')) {
+            // This is a nested subflow - mark as error
+            errors.add(blockId)
+          }
+        }
+      }
+    })
+
+    setNestedSubflowErrors(errors)
+    return errors.size === 0
+  }, [blocks])
+
+  // Log permissions when they load
+  useEffect(() => {
+    if (workspacePermissions) {
+      logger.info('Workspace permissions loaded in workflow', {
+        workspaceId,
+        userCount: workspacePermissions.total,
+        permissions: workspacePermissions.users.map((u) => ({
+          email: u.email,
+          permissions: u.permissionType,
+        })),
+      })
+    }
+  }, [workspacePermissions, workspaceId])
+
+  // Log permissions errors
+  useEffect(() => {
+    if (permissionsError) {
+      logger.error('Failed to load workspace permissions', {
+        workspaceId,
+        error: permissionsError,
+      })
+    }
+  }, [permissionsError, workspaceId])
+
   // Helper function to update a node's parent with proper position calculation
   const updateNodeParent = useCallback(
     (nodeId: string, newParentId: string | null) => {
@@ -283,19 +332,27 @@ const WorkflowContent = React.memo(() => {
     }
   }, [debouncedAutoLayout])
 
-  // Initialize workflow system
+  // Listen for active workflow changes and join socket room
   useEffect(() => {
-    if (typeof window !== 'undefined') {
-      const initSync = async () => {
-        // Initialize sync system if not already initialized
-        await initializeSyncManagers()
-        // Note: setIsWorkflowReady is handled in the workflow data tracking effect below
+    const handleActiveWorkflowChanged = (event: CustomEvent) => {
+      const { workflowId } = event.detail
+      if (workflowId && isConnected) {
+        logger.info(`Active workflow changed to ${workflowId}, joining socket room`)
+        joinWorkflow(workflowId)
       }
+    }
+
+    window.addEventListener('active-workflow-changed', handleActiveWorkflowChanged as EventListener)
 
-      // Initialize sync system
-      initSync()
+    return () => {
+      window.removeEventListener(
+        'active-workflow-changed',
+        handleActiveWorkflowChanged as EventListener
+      )
     }
-  }, [])
+  }, [isConnected, joinWorkflow])
+
+  // Note: Workflow initialization now handled by Socket.IO system
 
   // Handle drops
   const findClosestOutput = useCallback(
@@ -508,7 +565,7 @@ const WorkflowContent = React.memo(() => {
               y: position.y - containerInfo.loopPosition.y,
             }
 
-            // Add the container as a child of the parent container
+            // Add the container as a child of the parent container (will be marked as error)
             addBlock(id, data.type, name, relativePosition, {
               width: 500,
               height: 300,
@@ -517,49 +574,6 @@ const WorkflowContent = React.memo(() => {
               extent: 'parent',
             })
 
-            // Auto-connect the nested container to nodes inside the parent container
-            const isAutoConnectEnabled = useGeneralStore.getState().isAutoConnectEnabled
-            if (isAutoConnectEnabled) {
-              // Try to find other nodes in the parent container to connect to
-              const containerNodes = getNodes().filter((n) => n.parentId === containerInfo.loopId)
-
-              if (containerNodes.length > 0) {
-                // Connect to the closest node in the container
-                const closestNode = containerNodes
-                  .map((n) => ({
-                    id: n.id,
-                    distance: Math.sqrt(
-                      (n.position.x - relativePosition.x) ** 2 +
-                        (n.position.y - relativePosition.y) ** 2
-                    ),
-                  }))
-                  .sort((a, b) => a.distance - b.distance)[0]
-
-                if (closestNode) {
-                  // Get appropriate source handle
-                  const sourceNode = getNodes().find((n) => n.id === closestNode.id)
-                  const sourceType = sourceNode?.data?.type
-
-                  // Default source handle
-                  let sourceHandle = 'source'
-
-                  // For condition blocks, use the condition-true handle
-                  if (sourceType === 'condition') {
-                    sourceHandle = 'condition-true'
-                  }
-
-                  addEdge({
-                    id: crypto.randomUUID(),
-                    source: closestNode.id,
-                    target: id,
-                    sourceHandle,
-                    targetHandle: 'target',
-                    type: 'workflowEdge',
-                  })
-                }
-              }
-            }
-
             // Resize the parent container to fit the new child container
             resizeLoopNodesWrapper()
           } else {
@@ -813,26 +827,16 @@ const WorkflowContent = React.memo(() => {
         return
       }
 
-      // If no workflows exist after loading is complete, create initial workflow
-      if (workflowIds.length === 0) {
-        logger.info('No workflows found after loading complete, creating initial workflow')
-
-        // Generate numbered workflow name based on existing workflows
-        const existingWorkflowCount = Object.keys(workflows).length
-        const workflowNumber = existingWorkflowCount + 1
-        const workflowName = `Workflow ${workflowNumber}`
-
-        const newId = createWorkflow({
-          name: workflowName,
-          description: 'Getting started with agents',
-          isInitial: true,
-        })
-        router.replace(`/w/${newId}`)
+      // If no workflows exist, redirect to workspace root to let server handle workflow creation
+      if (workflowIds.length === 0 && !isLoading) {
+        logger.info('No workflows found, redirecting to workspace root')
+        router.replace('/w')
         return
       }
 
       // Navigate to existing workflow or first available
       if (!workflows[currentId]) {
+        logger.info(`Workflow ${currentId} not found, redirecting to first available workflow`)
         router.replace(`/w/${workflowIds[0]}`)
         return
       }
@@ -878,6 +882,7 @@ const WorkflowContent = React.memo(() => {
 
       // Handle container nodes differently
       if (block.type === 'loop') {
+        const hasNestedError = nestedSubflowErrors.has(block.id)
         nodeArray.push({
           id: block.id,
           type: 'loopNode',
@@ -889,6 +894,7 @@ const WorkflowContent = React.memo(() => {
             ...block.data,
             width: block.data?.width || 500,
             height: block.data?.height || 300,
+            hasNestedError,
           },
         })
         return
@@ -896,6 +902,7 @@ const WorkflowContent = React.memo(() => {
 
       // Handle parallel nodes
       if (block.type === 'parallel') {
+        const hasNestedError = nestedSubflowErrors.has(block.id)
         nodeArray.push({
           id: block.id,
           type: 'parallelNode',
@@ -907,6 +914,7 @@ const WorkflowContent = React.memo(() => {
             ...block.data,
             width: block.data?.width || 500,
             height: block.data?.height || 300,
+            hasNestedError,
           },
         })
         return
@@ -946,7 +954,7 @@ const WorkflowContent = React.memo(() => {
     })
 
     return nodeArray
-  }, [blocks, activeBlockIds, pendingBlocks, isDebugModeEnabled])
+  }, [blocks, activeBlockIds, pendingBlocks, isDebugModeEnabled, nestedSubflowErrors])
 
   // Update nodes
   const onNodesChange = useCallback(
@@ -1000,6 +1008,11 @@ const WorkflowContent = React.memo(() => {
     })
   }, [blocks, updateBlockPosition, updateParentId, getNodeAbsolutePositionWrapper])
 
+  // Validate nested subflows whenever blocks change
+  useEffect(() => {
+    validateNestedSubflows()
+  }, [blocks, validateNestedSubflows])
+
   // Update edges
   const onEdgesChange = useCallback(
     (changes: any) => {
@@ -1092,7 +1105,7 @@ const WorkflowContent = React.memo(() => {
 
   // Handle node drag to detect intersections with container nodes
   const onNodeDrag = useCallback(
-    (event: React.MouseEvent, node: any) => {
+    (_event: React.MouseEvent, node: any) => {
       // Store currently dragged node ID
       setDraggedNodeId(node.id)
 
@@ -1247,7 +1260,7 @@ const WorkflowContent = React.memo(() => {
 
   // Add in a nodeDrag start event to set the dragStartParentId
   const onNodeDragStart = useCallback(
-    (event: React.MouseEvent, node: any) => {
+    (_event: React.MouseEvent, node: any) => {
       // Store the original parent ID when starting to drag
       const currentParentId = node.parentId || blocks[node.id]?.data?.parentId || null
       setDragStartParentId(currentParentId)
@@ -1257,7 +1270,7 @@ const WorkflowContent = React.memo(() => {
 
   // Handle node drag stop to establish parent-child relationships
   const onNodeDragStop = useCallback(
-    (event: React.MouseEvent, node: any) => {
+    (_event: React.MouseEvent, node: any) => {
       // Clear UI effects
       document.querySelectorAll('.loop-node-drag-over, .parallel-node-drag-over').forEach((el) => {
         el.classList.remove('loop-node-drag-over', 'parallel-node-drag-over')
@@ -1396,7 +1409,11 @@ const WorkflowContent = React.memo(() => {
     const handleSubBlockValueUpdate = (event: CustomEvent) => {
       const { blockId, subBlockId, value } = event.detail
       if (blockId && subBlockId) {
-        setSubBlockValue(blockId, subBlockId, value)
+        // Only emit the socket update, don't update the store again
+        // The store was already updated in the setValue function
+        if (isConnected && currentWorkflowId && activeWorkflowId === currentWorkflowId) {
+          emitSubblockUpdate(blockId, subBlockId, value)
+        }
       }
     }
 
@@ -1408,7 +1425,7 @@ const WorkflowContent = React.memo(() => {
         handleSubBlockValueUpdate as EventListener
       )
     }
-  }, [setSubBlockValue])
+  }, [emitSubblockUpdate, isConnected, currentWorkflowId, activeWorkflowId])
 
   // Show skeleton UI while loading, then smoothly transition to real content
   const showSkeletonUI = !isWorkflowReady
@@ -1417,7 +1434,7 @@ const WorkflowContent = React.memo(() => {
     return (
       <div className='flex h-screen w-full flex-col overflow-hidden'>
         <SkeletonLoading showSkeleton={true} isSidebarCollapsed={isSidebarCollapsed}>
-          <ControlBar />
+          <ControlBar hasValidationErrors={nestedSubflowErrors.size > 0} />
         </SkeletonLoading>
         <Toolbar />
         <div
@@ -1438,7 +1455,7 @@ const WorkflowContent = React.memo(() => {
   return (
     <div className='flex h-screen w-full flex-col overflow-hidden'>
       <div className={`transition-all duration-200 ${isSidebarCollapsed ? 'ml-14' : 'ml-60'}`}>
-        <ControlBar />
+        <ControlBar hasValidationErrors={nestedSubflowErrors.size > 0} />
       </div>
       <Toolbar />
       <div
@@ -1448,6 +1465,7 @@ const WorkflowContent = React.memo(() => {
           <Panel />
           <NotificationList />
         </div>
+
         <ReactFlow
           nodes={nodes}
           edges={edgesWithSelection}
@@ -1470,7 +1488,7 @@ const WorkflowContent = React.memo(() => {
             strokeDasharray: '5,5',
           }}
           connectionLineType={ConnectionLineType.SmoothStep}
-          onNodeClick={(e, node) => {
+          onNodeClick={(e, _node) => {
             e.stopPropagation()
           }}
           onPaneClick={onPaneClick}
diff --git a/apps/sim/app/w/components/sidebar/components/folder-tree/folder-tree.tsx b/apps/sim/app/w/components/sidebar/components/folder-tree/folder-tree.tsx
index 818dd1d3b3c..8500d3c72e2 100644
--- a/apps/sim/app/w/components/sidebar/components/folder-tree/folder-tree.tsx
+++ b/apps/sim/app/w/components/sidebar/components/folder-tree/folder-tree.tsx
@@ -17,7 +17,7 @@ interface FolderSectionProps {
   workflowsByFolder: Record<string, WorkflowMetadata[]>
   expandedFolders: Set<string>
   pathname: string
-  updateWorkflow: (id: string, updates: Partial<WorkflowMetadata>) => void
+  updateWorkflow: (id: string, updates: Partial<WorkflowMetadata>) => Promise<void>
   renderFolderTree: (
     nodes: FolderTreeNode[],
     level: number,
@@ -97,7 +97,7 @@ function FolderSection({
 
 // Custom hook for drag and drop handling
 function useDragHandlers(
-  updateWorkflow: (id: string, updates: Partial<WorkflowMetadata>) => void,
+  updateWorkflow: (id: string, updates: Partial<WorkflowMetadata>) => Promise<void>,
   targetFolderId: string | null, // null for root
   logMessage?: string
 ) {
@@ -115,7 +115,7 @@ function useDragHandlers(
     setIsDragOver(false)
   }
 
-  const handleDrop = (e: React.DragEvent) => {
+  const handleDrop = async (e: React.DragEvent) => {
     e.preventDefault()
     e.stopPropagation()
     setIsDragOver(false)
@@ -125,9 +125,10 @@ function useDragHandlers(
       const workflowIds = JSON.parse(workflowIdsData) as string[]
 
       try {
-        workflowIds.forEach((workflowId) =>
-          updateWorkflow(workflowId, { folderId: targetFolderId })
-        )
+        // Update workflows sequentially to avoid race conditions
+        for (const workflowId of workflowIds) {
+          await updateWorkflow(workflowId, { folderId: targetFolderId })
+        }
         console.log(logMessage || `Moved ${workflowIds.length} workflow(s)`)
       } catch (error) {
         console.error('Failed to move workflows:', error)
diff --git a/apps/sim/app/w/layout.tsx b/apps/sim/app/w/layout.tsx
index 2cbb416b910..42ac184a820 100644
--- a/apps/sim/app/w/layout.tsx
+++ b/apps/sim/app/w/layout.tsx
@@ -1,15 +1,18 @@
+import { WorkspaceProvider } from '@/providers/workspace-provider'
 import Providers from './components/providers/providers'
 import { Sidebar } from './components/sidebar/sidebar'
 
 export default function WorkspaceLayout({ children }: { children: React.ReactNode }) {
   return (
-    <Providers>
-      <div className='flex min-h-screen w-full'>
-        <div className='z-20'>
-          <Sidebar />
+    <WorkspaceProvider>
+      <Providers>
+        <div className='flex min-h-screen w-full'>
+          <div className='z-20'>
+            <Sidebar />
+          </div>
+          <div className='flex flex-1 flex-col'>{children}</div>
         </div>
-        <div className='flex flex-1 flex-col'>{children}</div>
-      </div>
-    </Providers>
+      </Providers>
+    </WorkspaceProvider>
   )
 }
diff --git a/apps/sim/app/w/marketplace/components/workflow-card.tsx b/apps/sim/app/w/marketplace/components/workflow-card.tsx
index db7ecd5146a..82db83df0b7 100644
--- a/apps/sim/app/w/marketplace/components/workflow-card.tsx
+++ b/apps/sim/app/w/marketplace/components/workflow-card.tsx
@@ -63,7 +63,7 @@ export function WorkflowCard({ workflow, onHover }: WorkflowCardProps) {
 
       // Create a local copy of the marketplace workflow
       if (workflow.workflowState) {
-        const newWorkflowId = createWorkflow({
+        const newWorkflowId = await createWorkflow({
           name: `${workflow.name} (Copy)`,
           description: workflow.description,
           marketplaceId: workflow.id,
diff --git a/apps/sim/app/w/page.tsx b/apps/sim/app/w/page.tsx
new file mode 100644
index 00000000000..fea6f1d2df9
--- /dev/null
+++ b/apps/sim/app/w/page.tsx
@@ -0,0 +1,38 @@
+'use client'
+
+import { useEffect } from 'react'
+import { useRouter } from 'next/navigation'
+import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
+
+export default function WorkflowsPage() {
+  const router = useRouter()
+  const { workflows, isLoading } = useWorkflowRegistry()
+
+  useEffect(() => {
+    // Wait for workflows to load
+    if (isLoading) return
+
+    const workflowIds = Object.keys(workflows)
+
+    // If we have workflows, redirect to the first one
+    if (workflowIds.length > 0) {
+      router.replace(`/w/${workflowIds[0]}`)
+      return
+    }
+
+    // If no workflows exist, this means the workspace creation didn't work properly
+    // or the user doesn't have any workspaces. Redirect to home to let the system
+    // handle workspace/workflow creation properly.
+    router.replace('/')
+  }, [workflows, isLoading, router])
+
+  // Show loading state while determining where to redirect
+  return (
+    <div className='flex h-screen items-center justify-center'>
+      <div className='text-center'>
+        <div className='mx-auto mb-4 h-8 w-8 animate-spin rounded-full border-blue-600 border-b-2' />
+        <p className='text-gray-600'>Loading workflows...</p>
+      </div>
+    </div>
+  )
+}
diff --git a/apps/sim/contexts/socket-context.tsx b/apps/sim/contexts/socket-context.tsx
new file mode 100644
index 00000000000..7b7627a3041
--- /dev/null
+++ b/apps/sim/contexts/socket-context.tsx
@@ -0,0 +1,418 @@
+'use client'
+
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+} from 'react'
+import { io, type Socket } from 'socket.io-client'
+import { createLogger } from '@/lib/logs/console-logger'
+
+const logger = createLogger('SocketContext')
+
+interface User {
+  id: string
+  name?: string
+  email?: string
+}
+
+interface PresenceUser {
+  socketId: string
+  userId: string
+  userName: string
+  cursor?: { x: number; y: number }
+  selection?: { type: 'block' | 'edge' | 'none'; id?: string }
+}
+
+interface SocketContextType {
+  socket: Socket | null
+  isConnected: boolean
+  isConnecting: boolean
+  currentWorkflowId: string | null
+  presenceUsers: PresenceUser[]
+  joinWorkflow: (workflowId: string) => void
+  leaveWorkflow: () => void
+  emitWorkflowOperation: (operation: string, target: string, payload: any) => void
+  emitSubblockUpdate: (blockId: string, subblockId: string, value: any) => void
+  emitCursorUpdate: (cursor: { x: number; y: number }) => void
+  emitSelectionUpdate: (selection: { type: 'block' | 'edge' | 'none'; id?: string }) => void
+  // Event handlers for receiving real-time updates
+  onWorkflowOperation: (handler: (data: any) => void) => void
+  onSubblockUpdate: (handler: (data: any) => void) => void
+  onCursorUpdate: (handler: (data: any) => void) => void
+  onSelectionUpdate: (handler: (data: any) => void) => void
+  onUserJoined: (handler: (data: any) => void) => void
+  onUserLeft: (handler: (data: any) => void) => void
+  onWorkflowDeleted: (handler: (data: any) => void) => void
+}
+
+const SocketContext = createContext<SocketContextType>({
+  socket: null,
+  isConnected: false,
+  isConnecting: false,
+  currentWorkflowId: null,
+  presenceUsers: [],
+  joinWorkflow: () => {},
+  leaveWorkflow: () => {},
+  emitWorkflowOperation: () => {},
+  emitSubblockUpdate: () => {},
+  emitCursorUpdate: () => {},
+  emitSelectionUpdate: () => {},
+  onWorkflowOperation: () => {},
+  onSubblockUpdate: () => {},
+  onCursorUpdate: () => {},
+  onSelectionUpdate: () => {},
+  onUserJoined: () => {},
+  onUserLeft: () => {},
+  onWorkflowDeleted: () => {},
+})
+
+export const useSocket = () => useContext(SocketContext)
+
+interface SocketProviderProps {
+  children: ReactNode
+  user?: User
+}
+
+export function SocketProvider({ children, user }: SocketProviderProps) {
+  const [socket, setSocket] = useState<Socket | null>(null)
+  const [isConnected, setIsConnected] = useState(false)
+  const [isConnecting, setIsConnecting] = useState(false)
+  const [currentWorkflowId, setCurrentWorkflowId] = useState<string | null>(null)
+  const [presenceUsers, setPresenceUsers] = useState<PresenceUser[]>([])
+
+  // Use refs to store event handlers to avoid stale closures
+  const eventHandlers = useRef<{
+    workflowOperation?: (data: any) => void
+    subblockUpdate?: (data: any) => void
+    cursorUpdate?: (data: any) => void
+    selectionUpdate?: (data: any) => void
+    userJoined?: (data: any) => void
+    userLeft?: (data: any) => void
+    workflowDeleted?: (data: any) => void
+  }>({})
+
+  // Initialize socket when user is available
+  useEffect(() => {
+    if (!user?.id || socket) return
+
+    logger.info('Initializing socket connection for user:', user.id)
+    setIsConnecting(true)
+
+    const initializeSocket = async () => {
+      try {
+        // Generate one-time token for socket authentication
+        const tokenResponse = await fetch('/api/auth/socket-token', {
+          method: 'POST',
+          credentials: 'include',
+        })
+
+        if (!tokenResponse.ok) {
+          throw new Error('Failed to generate socket token')
+        }
+
+        const { token } = await tokenResponse.json()
+
+        const socketUrl = process.env.NEXT_PUBLIC_SOCKET_URL || 'http://localhost:3002'
+
+        logger.info('Attempting to connect to Socket.IO server', {
+          url: socketUrl,
+          userId: user?.id || 'no-user',
+          hasToken: !!token,
+          timestamp: new Date().toISOString(),
+        })
+
+        const socketInstance = io(socketUrl, {
+          transports: ['polling', 'websocket'],
+          withCredentials: true,
+          reconnectionAttempts: 5,
+          timeout: 10000,
+          auth: {
+            token, // Send one-time token for authentication
+          },
+        })
+
+        // Connection events
+        socketInstance.on('connect', () => {
+          setIsConnected(true)
+          setIsConnecting(false)
+          logger.info('Socket connected successfully', {
+            socketId: socketInstance.id,
+            connected: socketInstance.connected,
+            transport: socketInstance.io.engine?.transport?.name,
+          })
+        })
+
+        socketInstance.on('disconnect', (reason) => {
+          setIsConnected(false)
+          setIsConnecting(false)
+          logger.info('Socket disconnected', { reason })
+
+          // Clear presence when disconnected
+          setPresenceUsers([])
+        })
+
+        socketInstance.on('connect_error', (error: any) => {
+          setIsConnecting(false)
+          logger.error('Socket connection error:', {
+            message: error.message,
+            stack: error.stack,
+            description: error.description,
+            type: error.type,
+            transport: error.transport,
+          })
+        })
+
+        // Add reconnection logging
+        socketInstance.on('reconnect', (attemptNumber) => {
+          logger.info('Socket reconnected', { attemptNumber })
+        })
+
+        socketInstance.on('reconnect_attempt', (attemptNumber) => {
+          logger.info('Socket reconnection attempt', { attemptNumber })
+        })
+
+        socketInstance.on('reconnect_error', (error: any) => {
+          logger.error('Socket reconnection error:', error)
+        })
+
+        socketInstance.on('reconnect_failed', () => {
+          logger.error('Socket reconnection failed - all attempts exhausted')
+        })
+
+        // Presence events
+        socketInstance.on('presence-update', (users: PresenceUser[]) => {
+          setPresenceUsers(users)
+        })
+
+        socketInstance.on('user-joined', (userData) => {
+          setPresenceUsers((prev) => [...prev, userData])
+          eventHandlers.current.userJoined?.(userData)
+        })
+
+        socketInstance.on('user-left', ({ userId, socketId }) => {
+          setPresenceUsers((prev) => prev.filter((u) => u.socketId !== socketId))
+          eventHandlers.current.userLeft?.({ userId, socketId })
+        })
+
+        // Workflow operation events
+        socketInstance.on('workflow-operation', (data) => {
+          eventHandlers.current.workflowOperation?.(data)
+        })
+
+        // Subblock update events
+        socketInstance.on('subblock-update', (data) => {
+          eventHandlers.current.subblockUpdate?.(data)
+        })
+
+        // Workflow deletion events
+        socketInstance.on('workflow-deleted', (data) => {
+          logger.warn(`Workflow ${data.workflowId} has been deleted`)
+          // Clear current workflow ID if it matches the deleted workflow
+          if (currentWorkflowId === data.workflowId) {
+            setCurrentWorkflowId(null)
+            setPresenceUsers([])
+          }
+          eventHandlers.current.workflowDeleted?.(data)
+        })
+
+        // Cursor update events
+        socketInstance.on('cursor-update', (data) => {
+          setPresenceUsers((prev) =>
+            prev.map((user) =>
+              user.socketId === data.socketId ? { ...user, cursor: data.cursor } : user
+            )
+          )
+          eventHandlers.current.cursorUpdate?.(data)
+        })
+
+        // Selection update events
+        socketInstance.on('selection-update', (data) => {
+          setPresenceUsers((prev) =>
+            prev.map((user) =>
+              user.socketId === data.socketId ? { ...user, selection: data.selection } : user
+            )
+          )
+          eventHandlers.current.selectionUpdate?.(data)
+        })
+
+        // Enhanced error handling for new server events
+        socketInstance.on('error', (error) => {
+          logger.error('Socket error:', error)
+        })
+
+        socketInstance.on('operation-error', (error) => {
+          logger.error('Operation error:', error)
+        })
+
+        socketInstance.on('operation-forbidden', (error) => {
+          logger.warn('Operation forbidden:', error)
+          // Could show a toast notification to user
+        })
+
+        socketInstance.on('operation-confirmed', (data) => {
+          logger.debug('Operation confirmed:', data)
+        })
+
+        socketInstance.on('workflow-state', (state) => {
+          logger.info('Received workflow state from server:', state)
+          // This will be used to sync initial state when joining a workflow
+        })
+
+        setSocket(socketInstance)
+
+        return () => {
+          socketInstance.close()
+        }
+      } catch (error) {
+        logger.error('Failed to initialize socket with token:', error)
+        setIsConnecting(false)
+      }
+    }
+
+    // Start the socket initialization
+    initializeSocket()
+  }, [user?.id])
+
+  // Join workflow room
+  const joinWorkflow = useCallback(
+    (workflowId: string) => {
+      if (socket && user?.id) {
+        logger.info(`Joining workflow: ${workflowId}`)
+        socket.emit('join-workflow', {
+          workflowId, // Server gets user info from authenticated session
+        })
+        setCurrentWorkflowId(workflowId)
+      }
+    },
+    [socket, user]
+  )
+
+  // Leave current workflow room
+  const leaveWorkflow = useCallback(() => {
+    if (socket && currentWorkflowId) {
+      logger.info(`Leaving workflow: ${currentWorkflowId}`)
+      socket.emit('leave-workflow')
+      setCurrentWorkflowId(null)
+      setPresenceUsers([])
+    }
+  }, [socket, currentWorkflowId])
+
+  // Emit workflow operations (blocks, edges, subflows)
+  const emitWorkflowOperation = useCallback(
+    (operation: string, target: string, payload: any) => {
+      if (socket && currentWorkflowId) {
+        socket.emit('workflow-operation', {
+          operation,
+          target,
+          payload,
+          timestamp: Date.now(),
+        })
+      }
+    },
+    [socket, currentWorkflowId]
+  )
+
+  // Emit subblock value updates
+  const emitSubblockUpdate = useCallback(
+    (blockId: string, subblockId: string, value: any) => {
+      // Only emit if socket is connected and we're in a valid workflow room
+      if (socket && currentWorkflowId) {
+        socket.emit('subblock-update', {
+          blockId,
+          subblockId,
+          value,
+          timestamp: Date.now(),
+        })
+      } else {
+        logger.warn('Cannot emit subblock update: no socket connection or workflow room', {
+          hasSocket: !!socket,
+          currentWorkflowId,
+          blockId,
+          subblockId,
+        })
+      }
+    },
+    [socket, currentWorkflowId]
+  )
+
+  // Emit cursor position updates
+  const emitCursorUpdate = useCallback(
+    (cursor: { x: number; y: number }) => {
+      if (socket && currentWorkflowId) {
+        socket.emit('cursor-update', { cursor })
+      }
+    },
+    [socket, currentWorkflowId]
+  )
+
+  // Emit selection updates
+  const emitSelectionUpdate = useCallback(
+    (selection: { type: 'block' | 'edge' | 'none'; id?: string }) => {
+      if (socket && currentWorkflowId) {
+        socket.emit('selection-update', { selection })
+      }
+    },
+    [socket, currentWorkflowId]
+  )
+
+  // Event handler registration functions
+  const onWorkflowOperation = useCallback((handler: (data: any) => void) => {
+    eventHandlers.current.workflowOperation = handler
+  }, [])
+
+  const onSubblockUpdate = useCallback((handler: (data: any) => void) => {
+    eventHandlers.current.subblockUpdate = handler
+  }, [])
+
+  const onCursorUpdate = useCallback((handler: (data: any) => void) => {
+    eventHandlers.current.cursorUpdate = handler
+  }, [])
+
+  const onSelectionUpdate = useCallback((handler: (data: any) => void) => {
+    eventHandlers.current.selectionUpdate = handler
+  }, [])
+
+  const onUserJoined = useCallback((handler: (data: any) => void) => {
+    eventHandlers.current.userJoined = handler
+  }, [])
+
+  const onUserLeft = useCallback((handler: (data: any) => void) => {
+    eventHandlers.current.userLeft = handler
+  }, [])
+
+  const onWorkflowDeleted = useCallback((handler: (data: any) => void) => {
+    eventHandlers.current.workflowDeleted = handler
+  }, [])
+
+  return (
+    <SocketContext.Provider
+      value={{
+        socket,
+        isConnected,
+        isConnecting,
+        currentWorkflowId,
+        presenceUsers,
+        joinWorkflow,
+        leaveWorkflow,
+        emitWorkflowOperation,
+        emitSubblockUpdate,
+        emitCursorUpdate,
+        emitSelectionUpdate,
+        onWorkflowOperation,
+        onSubblockUpdate,
+        onCursorUpdate,
+        onSelectionUpdate,
+        onUserJoined,
+        onUserLeft,
+        onWorkflowDeleted,
+      }}
+    >
+      {children}
+    </SocketContext.Provider>
+  )
+}
diff --git a/apps/sim/executor/handlers/condition/condition-handler.test.ts b/apps/sim/executor/handlers/condition/condition-handler.test.ts
index ca955486529..040184ecd40 100644
--- a/apps/sim/executor/handlers/condition/condition-handler.test.ts
+++ b/apps/sim/executor/handlers/condition/condition-handler.test.ts
@@ -98,6 +98,7 @@ describe('ConditionBlockHandler', () => {
           {
             output: { response: { value: 10, text: 'hello' } },
             executed: true,
+            executionTime: 100,
           },
         ],
       ]),
diff --git a/apps/sim/executor/handlers/loop/loop-handler.ts b/apps/sim/executor/handlers/loop/loop-handler.ts
index 799209fd17b..7d805e098a2 100644
--- a/apps/sim/executor/handlers/loop/loop-handler.ts
+++ b/apps/sim/executor/handlers/loop/loop-handler.ts
@@ -29,6 +29,11 @@ export class LoopBlockHandler implements BlockHandler {
     // Get the loop configuration from the workflow
     const loop = context.workflow?.loops?.[block.id]
     if (!loop) {
+      logger.error(`Loop configuration not found for block ${block.id}`, {
+        blockId: block.id,
+        availableLoops: Object.keys(context.workflow?.loops || {}),
+        workflowLoops: context.workflow?.loops,
+      })
       throw new Error(`Loop configuration not found for block ${block.id}`)
     }
 
diff --git a/apps/sim/executor/handlers/parallel/parallel-handler.test.ts b/apps/sim/executor/handlers/parallel/parallel-handler.test.ts
index 09517c77c45..fa69b3189bb 100644
--- a/apps/sim/executor/handlers/parallel/parallel-handler.test.ts
+++ b/apps/sim/executor/handlers/parallel/parallel-handler.test.ts
@@ -256,6 +256,8 @@ describe('ParallelBlockHandler', () => {
   it('should handle parallel without distribution', async () => {
     const handler = new ParallelBlockHandler(mockResolver as any)
     const block = createMockBlock('parallel-1')
+    // Ensure block.config.params doesn't have a count
+    block.config.params = {}
     const parallel: SerializedParallel = {
       id: 'parallel-1',
       nodes: ['agent-1'],
@@ -269,9 +271,9 @@ describe('ParallelBlockHandler', () => {
     expect((result as any).response).toMatchObject({
       parallelId: 'parallel-1',
       parallelCount: 1,
-      distributionType: 'simple',
+      distributionType: 'count',
       started: true,
-      message: 'Initialized 1 parallel executions',
+      message: 'Initialized 1 parallel execution',
     })
 
     // Should not have items when no distribution
diff --git a/apps/sim/executor/handlers/parallel/parallel-handler.ts b/apps/sim/executor/handlers/parallel/parallel-handler.ts
index 4f76d7172c6..f133cf99bdc 100644
--- a/apps/sim/executor/handlers/parallel/parallel-handler.ts
+++ b/apps/sim/executor/handlers/parallel/parallel-handler.ts
@@ -28,6 +28,11 @@ export class ParallelBlockHandler implements BlockHandler {
     // Get the parallel configuration from the workflow
     const parallel = context.workflow?.parallels?.[block.id]
     if (!parallel) {
+      logger.error(`Parallel configuration not found for block ${block.id}`, {
+        blockId: block.id,
+        availableParallels: Object.keys(context.workflow?.parallels || {}),
+        workflowParallels: context.workflow?.parallels,
+      })
       throw new Error(`Parallel configuration not found for block ${block.id}`)
     }
 
@@ -112,9 +117,21 @@ export class ParallelBlockHandler implements BlockHandler {
     if (!parallelState) {
       logger.info(`Initializing parallel block ${block.id}`)
 
-      // Get the parallel type and count from block data
-      const parallelType = block.config?.params?.parallelType || 'collection'
-      const countValue = block.config?.params?.count || 5
+      // Get the parallel type from the parallel config (explicit type to avoid inference bugs)
+      // If no explicit parallelType is set, infer it based on whether distribution exists
+      let parallelType = parallel.parallelType
+      if (!parallelType) {
+        // If there's a distribution, default to 'collection', otherwise default to 'count'
+        parallelType = parallel.distribution ? 'collection' : 'count'
+      }
+      const countValue = parallel.count || block.config?.params?.count || 1
+
+      logger.info(`Parallel ${block.id} configuration:`, {
+        parallelType,
+        countValue,
+        distribution: parallel.distribution,
+        configSource: parallel.count ? 'workflow_subflows' : 'block.config',
+      })
 
       // Evaluate distribution items if provided and type is collection
       let distributionItems: any[] | Record<string, any> | null = null
@@ -133,7 +150,7 @@ export class ParallelBlockHandler implements BlockHandler {
         // Use the count value for count-based parallel
         parallelCount = Math.min(20, Math.max(1, countValue))
         logger.info(`Parallel ${block.id} will execute ${parallelCount} times based on count`)
-      } else if (distributionItems) {
+      } else if (parallelType === 'collection' && distributionItems) {
         // Use distribution items length for collection-based parallel
         parallelCount = Array.isArray(distributionItems)
           ? distributionItems.length
@@ -141,6 +158,10 @@ export class ParallelBlockHandler implements BlockHandler {
         logger.info(
           `Parallel ${block.id} will execute ${parallelCount} times based on distribution items`
         )
+      } else {
+        // Simple parallel - single execution
+        parallelCount = 1
+        logger.info(`Parallel ${block.id} will execute ${parallelCount} time (simple mode)`)
       }
 
       // Initialize parallel execution state
@@ -153,16 +174,18 @@ export class ParallelBlockHandler implements BlockHandler {
         currentIteration: 1, // Start at 1 to indicate activation
         parallelType,
       }
+
+      // Initialize parallelExecutions if it doesn't exist
+      if (!context.parallelExecutions) {
+        context.parallelExecutions = new Map()
+      }
       context.parallelExecutions.set(block.id, parallelState)
 
       // Store the distribution items for access by child blocks
       if (distributionItems) {
         context.loopItems.set(`${block.id}_items`, distributionItems)
-      } else if (parallelType === 'count') {
-        // For count-based parallel, create an array of indices
-        const indices = Array.from({ length: parallelCount }, (_, i) => i)
-        context.loopItems.set(`${block.id}_items`, indices)
       }
+      // Note: For simple count-based parallels without distribution, we don't store items
 
       // Activate all child nodes (the executor will handle creating virtual instances)
       const parallelStartConnections =
@@ -179,10 +202,9 @@ export class ParallelBlockHandler implements BlockHandler {
         response: {
           parallelId: block.id,
           parallelCount,
-          distributionType:
-            parallelType === 'count' ? 'count' : distributionItems ? 'distributed' : 'simple',
+          distributionType: parallelType === 'count' ? 'count' : 'distributed',
           started: true,
-          message: `Initialized ${parallelCount} parallel executions`,
+          message: `Initialized ${parallelCount} parallel execution${parallelCount > 1 ? 's' : ''}`,
         },
       }
     }
diff --git a/apps/sim/executor/path.test.ts b/apps/sim/executor/path.test.ts
index b2cdda947e4..8f03d49b1a0 100644
--- a/apps/sim/executor/path.test.ts
+++ b/apps/sim/executor/path.test.ts
@@ -170,6 +170,7 @@ describe('PathTracker', () => {
         const blockState: BlockState = {
           output: { response: { selectedPath: { blockId: 'block1' } } },
           executed: true,
+          executionTime: 100,
         }
         mockContext.blockStates.set('router1', blockState)
 
@@ -183,6 +184,7 @@ describe('PathTracker', () => {
         const blockState: BlockState = {
           output: { response: {} },
           executed: true,
+          executionTime: 100,
         }
         mockContext.blockStates.set('router1', blockState)
 
@@ -198,6 +200,7 @@ describe('PathTracker', () => {
         const blockState: BlockState = {
           output: { response: { selectedConditionId: 'if' } },
           executed: true,
+          executionTime: 100,
         }
         mockContext.blockStates.set('condition1', blockState)
 
@@ -211,6 +214,7 @@ describe('PathTracker', () => {
         const blockState: BlockState = {
           output: { response: { selectedConditionId: 'unknown' } },
           executed: true,
+          executionTime: 100,
         }
         mockContext.blockStates.set('condition1', blockState)
 
@@ -235,6 +239,7 @@ describe('PathTracker', () => {
         const blockState: BlockState = {
           output: { response: { data: 'success' } },
           executed: true,
+          executionTime: 100,
         }
         mockContext.blockStates.set('block1', blockState)
         mockContext.executedBlocks.add('block1')
@@ -256,6 +261,7 @@ describe('PathTracker', () => {
         const blockState: BlockState = {
           output: { error: 'Something failed', response: { error: 'Something failed' } },
           executed: true,
+          executionTime: 100,
         }
         mockContext.blockStates.set('block1', blockState)
         mockContext.executedBlocks.add('block1')
@@ -328,10 +334,12 @@ describe('PathTracker', () => {
       const blockState1: BlockState = {
         output: { response: { data: 'success' } },
         executed: true,
+        executionTime: 100,
       }
       const blockState2: BlockState = {
         output: { response: { selectedPath: { blockId: 'block1' } } },
         executed: true,
+        executionTime: 150,
       }
       mockContext.blockStates.set('block1', blockState1)
       mockContext.blockStates.set('router1', blockState2)
diff --git a/apps/sim/executor/types.ts b/apps/sim/executor/types.ts
index e312b8e366b..b361fc3edd9 100644
--- a/apps/sim/executor/types.ts
+++ b/apps/sim/executor/types.ts
@@ -93,7 +93,7 @@ export interface ExecutionContext {
   }
 
   loopIterations: Map<string, number> // Tracks current iteration count for each loop
-  loopItems: Map<string, any[] | Record<string, any>> // Tracks current item for forEach loops and parallel distribution
+  loopItems: Map<string, any> // Tracks current item for forEach loops and parallel distribution
   completedLoops: Set<string> // Tracks which loops have completed all iterations
 
   // Parallel execution tracking
diff --git a/apps/sim/hooks/use-collaborative-workflow.ts b/apps/sim/hooks/use-collaborative-workflow.ts
new file mode 100644
index 00000000000..a62c34df101
--- /dev/null
+++ b/apps/sim/hooks/use-collaborative-workflow.ts
@@ -0,0 +1,555 @@
+import { useCallback, useEffect, useRef } from 'react'
+import type { Edge } from 'reactflow'
+import { createLogger } from '@/lib/logs/console-logger'
+import { useSocket } from '@/contexts/socket-context'
+import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
+import { useSubBlockStore } from '@/stores/workflows/subblock/store'
+import { useWorkflowStore } from '@/stores/workflows/workflow/store'
+import type { Position } from '@/stores/workflows/workflow/types'
+
+const logger = createLogger('CollaborativeWorkflow')
+
+export function useCollaborativeWorkflow() {
+  const {
+    isConnected,
+    currentWorkflowId,
+    presenceUsers,
+    joinWorkflow,
+    leaveWorkflow,
+    emitWorkflowOperation,
+    emitSubblockUpdate,
+    onWorkflowOperation,
+    onSubblockUpdate,
+    onUserJoined,
+    onUserLeft,
+    onWorkflowDeleted,
+  } = useSocket()
+
+  const { activeWorkflowId } = useWorkflowRegistry()
+  const workflowStore = useWorkflowStore()
+  const subBlockStore = useSubBlockStore()
+
+  // Track if we're applying remote changes to avoid infinite loops
+  const isApplyingRemoteChange = useRef(false)
+
+  // Join workflow room when active workflow changes
+  useEffect(() => {
+    if (activeWorkflowId && isConnected && currentWorkflowId !== activeWorkflowId) {
+      logger.info(`Joining workflow room: ${activeWorkflowId}`, {
+        isConnected,
+        currentWorkflowId,
+        activeWorkflowId,
+        presenceUsers: presenceUsers.length,
+      })
+      joinWorkflow(activeWorkflowId)
+    }
+  }, [activeWorkflowId, isConnected, currentWorkflowId, joinWorkflow])
+
+  // Log connection status changes
+  useEffect(() => {
+    logger.info('Collaborative workflow connection status changed', {
+      isConnected,
+      currentWorkflowId,
+      activeWorkflowId,
+      presenceUsers: presenceUsers.length,
+    })
+  }, [isConnected, currentWorkflowId, activeWorkflowId, presenceUsers.length])
+
+  // Handle incoming workflow operations from other users
+  useEffect(() => {
+    const handleWorkflowOperation = (data: any) => {
+      const { operation, target, payload, senderId, userId } = data
+
+      // Don't apply our own operations
+      if (isApplyingRemoteChange.current) return
+
+      logger.info(`Received ${operation} on ${target} from user ${userId}`)
+
+      // Apply the operation to local state
+      isApplyingRemoteChange.current = true
+
+      try {
+        if (target === 'block') {
+          switch (operation) {
+            case 'add':
+              workflowStore.addBlock(
+                payload.id,
+                payload.type,
+                payload.name,
+                payload.position,
+                payload.data,
+                payload.parentId,
+                payload.extent
+              )
+              break
+            case 'update-position':
+              workflowStore.updateBlockPosition(payload.id, payload.position)
+              break
+            case 'update-name':
+              workflowStore.updateBlockName(payload.id, payload.name)
+              break
+            case 'remove':
+              workflowStore.removeBlock(payload.id)
+              break
+            case 'toggle-enabled':
+              workflowStore.toggleBlockEnabled(payload.id)
+              break
+            case 'update-parent':
+              workflowStore.updateParentId(payload.id, payload.parentId, payload.extent)
+              break
+          }
+        } else if (target === 'edge') {
+          switch (operation) {
+            case 'add':
+              workflowStore.addEdge(payload as Edge)
+              break
+            case 'remove':
+              workflowStore.removeEdge(payload.id)
+              break
+          }
+        }
+      } catch (error) {
+        logger.error('Error applying remote operation:', error)
+      } finally {
+        isApplyingRemoteChange.current = false
+      }
+    }
+
+    const handleSubblockUpdate = (data: any) => {
+      const { blockId, subblockId, value, senderId, userId } = data
+
+      if (isApplyingRemoteChange.current) return
+
+      logger.info(`Received subblock update from user ${userId}: ${blockId}.${subblockId}`)
+
+      isApplyingRemoteChange.current = true
+
+      try {
+        // The setValue function automatically uses the active workflow ID
+        subBlockStore.setValue(blockId, subblockId, value)
+      } catch (error) {
+        logger.error('Error applying remote subblock update:', error)
+      } finally {
+        isApplyingRemoteChange.current = false
+      }
+    }
+
+    const handleUserJoined = (data: any) => {
+      logger.info(`User joined: ${data.userName}`)
+    }
+
+    const handleUserLeft = (data: any) => {
+      logger.info(`User left: ${data.userId}`)
+    }
+
+    const handleWorkflowDeleted = (data: any) => {
+      const { workflowId } = data
+      logger.warn(`Workflow ${workflowId} has been deleted`)
+
+      // If the deleted workflow is the currently active one, we need to handle this gracefully
+      if (activeWorkflowId === workflowId) {
+        logger.info(
+          `Currently active workflow ${workflowId} was deleted, stopping collaborative operations`
+        )
+        // The workflow registry should handle switching to another workflow
+        // We just need to stop any pending collaborative operations
+        isApplyingRemoteChange.current = false
+      }
+    }
+
+    // Register event handlers
+    onWorkflowOperation(handleWorkflowOperation)
+    onSubblockUpdate(handleSubblockUpdate)
+    onUserJoined(handleUserJoined)
+    onUserLeft(handleUserLeft)
+    onWorkflowDeleted(handleWorkflowDeleted)
+
+    return () => {
+      // Cleanup handled by socket context
+    }
+  }, [
+    onWorkflowOperation,
+    onSubblockUpdate,
+    onUserJoined,
+    onUserLeft,
+    onWorkflowDeleted,
+    workflowStore,
+    subBlockStore,
+    activeWorkflowId,
+  ])
+
+  // Collaborative workflow operations
+  const collaborativeAddBlock = useCallback(
+    (
+      id: string,
+      type: string,
+      name: string,
+      position: Position,
+      data?: Record<string, any>,
+      parentId?: string,
+      extent?: 'parent'
+    ) => {
+      // Apply locally first
+      workflowStore.addBlock(id, type, name, position, data, parentId, extent)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('add', 'block', {
+          id,
+          type,
+          name,
+          position,
+          data,
+          parentId,
+          extent,
+        })
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeRemoveBlock = useCallback(
+    (id: string) => {
+      // Apply locally first
+      workflowStore.removeBlock(id)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('remove', 'block', { id })
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateBlockPosition = useCallback(
+    (id: string, position: Position) => {
+      // Apply locally first
+      workflowStore.updateBlockPosition(id, position)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('update-position', 'block', { id, position })
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateBlockName = useCallback(
+    (id: string, name: string) => {
+      // Apply locally first
+      workflowStore.updateBlockName(id, name)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('update-name', 'block', { id, name })
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeToggleBlockEnabled = useCallback(
+    (id: string) => {
+      // Apply locally first
+      workflowStore.toggleBlockEnabled(id)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('toggle-enabled', 'block', { id })
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateParentId = useCallback(
+    (id: string, parentId: string, extent: 'parent') => {
+      // Apply locally first
+      workflowStore.updateParentId(id, parentId, extent)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('update-parent', 'block', { id, parentId, extent })
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeAddEdge = useCallback(
+    (edge: Edge) => {
+      // Apply locally first
+      workflowStore.addEdge(edge)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('add', 'edge', edge)
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeRemoveEdge = useCallback(
+    (edgeId: string) => {
+      // Apply locally first
+      workflowStore.removeEdge(edgeId)
+
+      // Then broadcast to other clients
+      if (!isApplyingRemoteChange.current) {
+        emitWorkflowOperation('remove', 'edge', { id: edgeId })
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeSetSubblockValue = useCallback(
+    (blockId: string, subblockId: string, value: any) => {
+      // Apply locally first - the store automatically uses the active workflow ID
+      subBlockStore.setValue(blockId, subblockId, value)
+
+      // Then broadcast to other clients, but only if we have a valid workflow connection
+      if (
+        !isApplyingRemoteChange.current &&
+        isConnected &&
+        currentWorkflowId &&
+        activeWorkflowId === currentWorkflowId
+      ) {
+        emitSubblockUpdate(blockId, subblockId, value)
+      } else if (!isConnected || !currentWorkflowId || activeWorkflowId !== currentWorkflowId) {
+        logger.debug('Skipping subblock update broadcast', {
+          isConnected,
+          currentWorkflowId,
+          activeWorkflowId,
+          blockId,
+          subblockId,
+        })
+      }
+    },
+    [subBlockStore, emitSubblockUpdate, isConnected, currentWorkflowId, activeWorkflowId]
+  )
+
+  // Collaborative loop/parallel configuration updates
+  const collaborativeUpdateLoopCount = useCallback(
+    (loopId: string, count: number) => {
+      // Apply locally first
+      workflowStore.updateLoopCount(loopId, count)
+
+      // Emit subflow update operation to persist configuration changes
+      if (!isApplyingRemoteChange.current) {
+        // Build the configuration manually to ensure it matches the database structure
+        const block = workflowStore.blocks[loopId]
+        if (block && block.type === 'loop') {
+          // Find child nodes
+          const childNodes = Object.values(workflowStore.blocks)
+            .filter((b) => b.data?.parentId === loopId)
+            .map((b) => b.id)
+
+          const config = {
+            id: loopId,
+            nodes: childNodes,
+            iterations: count,
+            loopType: block.data?.loopType || 'for',
+            forEachItems: block.data?.collection || '',
+          }
+
+          emitWorkflowOperation('update', 'subflow', {
+            id: loopId,
+            type: 'loop',
+            config,
+          })
+        }
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateLoopType = useCallback(
+    (loopId: string, loopType: 'for' | 'forEach') => {
+      // Apply locally first
+      workflowStore.updateLoopType(loopId, loopType)
+
+      // Emit subflow update operation to persist configuration changes
+      if (!isApplyingRemoteChange.current) {
+        const block = workflowStore.blocks[loopId]
+        if (block && block.type === 'loop') {
+          // Find child nodes
+          const childNodes = Object.values(workflowStore.blocks)
+            .filter((b) => b.data?.parentId === loopId)
+            .map((b) => b.id)
+
+          const config = {
+            id: loopId,
+            nodes: childNodes,
+            iterations: block.data?.count || 5,
+            loopType,
+            forEachItems: block.data?.collection || '',
+          }
+
+          emitWorkflowOperation('update', 'subflow', {
+            id: loopId,
+            type: 'loop',
+            config,
+          })
+        }
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateLoopCollection = useCallback(
+    (loopId: string, collection: string) => {
+      // Apply locally first
+      workflowStore.updateLoopCollection(loopId, collection)
+
+      // Emit subflow update operation to persist configuration changes
+      if (!isApplyingRemoteChange.current) {
+        const block = workflowStore.blocks[loopId]
+        if (block && block.type === 'loop') {
+          // Find child nodes
+          const childNodes = Object.values(workflowStore.blocks)
+            .filter((b) => b.data?.parentId === loopId)
+            .map((b) => b.id)
+
+          const config = {
+            id: loopId,
+            nodes: childNodes,
+            iterations: block.data?.count || 5,
+            loopType: block.data?.loopType || 'for',
+            forEachItems: collection,
+          }
+
+          emitWorkflowOperation('update', 'subflow', {
+            id: loopId,
+            type: 'loop',
+            config,
+          })
+        }
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateParallelCount = useCallback(
+    (parallelId: string, count: number) => {
+      // Apply locally first
+      workflowStore.updateParallelCount(parallelId, count)
+
+      // Emit subflow update operation to persist configuration changes
+      if (!isApplyingRemoteChange.current) {
+        const block = workflowStore.blocks[parallelId]
+        if (block && block.type === 'parallel') {
+          // Find child nodes
+          const childNodes = Object.values(workflowStore.blocks)
+            .filter((b) => b.data?.parentId === parallelId)
+            .map((b) => b.id)
+
+          const config = {
+            id: parallelId,
+            nodes: childNodes,
+            count: Math.max(1, Math.min(20, count)), // Clamp between 1-20
+            distribution: block.data?.collection || '',
+            parallelType: block.data?.parallelType || 'collection',
+          }
+
+          emitWorkflowOperation('update', 'subflow', {
+            id: parallelId,
+            type: 'parallel',
+            config,
+          })
+        }
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateParallelCollection = useCallback(
+    (parallelId: string, collection: string) => {
+      // Apply locally first
+      workflowStore.updateParallelCollection(parallelId, collection)
+
+      // Emit subflow update operation to persist configuration changes
+      if (!isApplyingRemoteChange.current) {
+        const parallels = workflowStore.parallels
+        const config = parallels[parallelId]
+
+        if (config) {
+          const block = workflowStore.blocks[parallelId]
+          emitWorkflowOperation('update', 'subflow', {
+            id: parallelId,
+            type: 'parallel',
+            config: {
+              ...config,
+              distribution: collection, // Ensure the new collection is included
+              parallelType: block?.data?.parallelType || 'collection', // Include parallelType
+            },
+          })
+        }
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  const collaborativeUpdateParallelType = useCallback(
+    (parallelId: string, parallelType: 'count' | 'collection') => {
+      // Apply locally first
+      workflowStore.updateParallelType(parallelId, parallelType)
+
+      // Emit subflow update operation to persist configuration changes
+      if (!isApplyingRemoteChange.current) {
+        const block = workflowStore.blocks[parallelId]
+        if (block && block.type === 'parallel') {
+          // Find child nodes
+          const childNodes = Object.values(workflowStore.blocks)
+            .filter((b) => b.data?.parentId === parallelId)
+            .map((b) => b.id)
+
+          const config = {
+            id: parallelId,
+            nodes: childNodes,
+            count: block.data?.count || 5,
+            distribution: block.data?.collection || '',
+            parallelType,
+          }
+
+          emitWorkflowOperation('update', 'subflow', {
+            id: parallelId,
+            type: 'parallel',
+            config,
+          })
+        }
+      }
+    },
+    [workflowStore, emitWorkflowOperation]
+  )
+
+  return {
+    // Connection status
+    isConnected,
+    currentWorkflowId,
+    presenceUsers,
+
+    // Workflow management
+    joinWorkflow,
+    leaveWorkflow,
+
+    // Collaborative operations
+    collaborativeAddBlock,
+    collaborativeUpdateBlockPosition,
+    collaborativeUpdateBlockName,
+    collaborativeRemoveBlock,
+    collaborativeToggleBlockEnabled,
+    collaborativeUpdateParentId,
+    collaborativeAddEdge,
+    collaborativeRemoveEdge,
+    collaborativeSetSubblockValue,
+
+    // Collaborative loop/parallel operations
+    collaborativeUpdateLoopCount,
+    collaborativeUpdateLoopType,
+    collaborativeUpdateLoopCollection,
+    collaborativeUpdateParallelCount,
+    collaborativeUpdateParallelCollection,
+    collaborativeUpdateParallelType,
+
+    // Direct access to stores for non-collaborative operations
+    workflowStore,
+    subBlockStore,
+  }
+}
diff --git a/apps/sim/lib/auth.ts b/apps/sim/lib/auth.ts
index 06681388692..68a3125ce72 100644
--- a/apps/sim/lib/auth.ts
+++ b/apps/sim/lib/auth.ts
@@ -2,7 +2,13 @@ import { stripe } from '@better-auth/stripe'
 import { betterAuth } from 'better-auth'
 import { drizzleAdapter } from 'better-auth/adapters/drizzle'
 import { nextCookies } from 'better-auth/next-js'
-import { createAuthMiddleware, emailOTP, genericOAuth, organization } from 'better-auth/plugins'
+import {
+  createAuthMiddleware,
+  emailOTP,
+  genericOAuth,
+  oneTimeToken,
+  organization,
+} from 'better-auth/plugins'
 import { and, eq } from 'drizzle-orm'
 import { headers } from 'next/headers'
 import { Resend } from 'resend'
@@ -60,6 +66,7 @@ export const auth = betterAuth({
   trustedOrigins: [
     env.NEXT_PUBLIC_APP_URL,
     ...(env.NEXT_PUBLIC_VERCEL_URL ? [`https://${env.NEXT_PUBLIC_VERCEL_URL}`] : []),
+    ...(env.NEXT_PUBLIC_SOCKET_URL ? [env.NEXT_PUBLIC_SOCKET_URL] : []),
   ].filter(Boolean),
   database: drizzleAdapter(db, {
     provider: 'pg',
@@ -179,6 +186,9 @@ export const auth = betterAuth({
   },
   plugins: [
     nextCookies(),
+    oneTimeToken({
+      expiresIn: 10, // 10 minutes - enough time for socket connection
+    }),
     emailOTP({
       sendVerificationOTP: async (data: {
         email: string
diff --git a/apps/sim/lib/env.ts b/apps/sim/lib/env.ts
index 6b43d8c1970..45287305e90 100644
--- a/apps/sim/lib/env.ts
+++ b/apps/sim/lib/env.ts
@@ -102,6 +102,7 @@ export const env = createEnv({
     LINEAR_CLIENT_SECRET: z.string().optional(),
     SLACK_CLIENT_ID: z.string().optional(),
     SLACK_CLIENT_SECRET: z.string().optional(),
+    SOCKET_SERVER_URL: z.string().url().optional(),
   },
 
   client: {
@@ -111,6 +112,7 @@ export const env = createEnv({
     NEXT_PUBLIC_GOOGLE_CLIENT_ID: z.string().optional(),
     NEXT_PUBLIC_GOOGLE_API_KEY: z.string().optional(),
     NEXT_PUBLIC_GOOGLE_PROJECT_NUMBER: z.string().optional(),
+    NEXT_PUBLIC_SOCKET_URL: z.string().url().optional(),
   },
 
   // Only need to define client variables, server variables are automatically handled
@@ -121,6 +123,7 @@ export const env = createEnv({
     NEXT_PUBLIC_GOOGLE_CLIENT_ID: getEnv('NEXT_PUBLIC_GOOGLE_CLIENT_ID'),
     NEXT_PUBLIC_GOOGLE_API_KEY: getEnv('NEXT_PUBLIC_GOOGLE_API_KEY'),
     NEXT_PUBLIC_GOOGLE_PROJECT_NUMBER: getEnv('NEXT_PUBLIC_GOOGLE_PROJECT_NUMBER'),
+    NEXT_PUBLIC_SOCKET_URL: getEnv('NEXT_PUBLIC_SOCKET_URL'),
   },
 })
 
diff --git a/apps/sim/lib/workflows/db-helpers.test.ts b/apps/sim/lib/workflows/db-helpers.test.ts
index 8f1668c5ef6..be9d2373447 100644
--- a/apps/sim/lib/workflows/db-helpers.test.ts
+++ b/apps/sim/lib/workflows/db-helpers.test.ts
@@ -72,6 +72,7 @@ vi.doMock('@/lib/logs/console-logger', () => ({
     info: vi.fn(),
     error: vi.fn(),
     warn: vi.fn(),
+    debug: vi.fn(),
   })),
 }))
 
@@ -225,22 +226,30 @@ describe('Database Helpers', () => {
 
   describe('loadWorkflowFromNormalizedTables', () => {
     it('should successfully load workflow data from normalized tables', async () => {
-      // Mock the database queries properly
+      // Reset all mocks first
+      vi.clearAllMocks()
+
+      // Mock each database query call separately since Promise.all makes 3 separate calls
       let callCount = 0
-      mockDb.select.mockReturnValue({
+      mockDb.select.mockImplementation(() => ({
         from: vi.fn().mockReturnValue({
           where: vi.fn().mockImplementation(() => {
             callCount++
-            if (callCount === 1) return mockBlocksFromDb // blocks query
-            if (callCount === 2) return mockEdgesFromDb // edges query
-            if (callCount === 3) return mockSubflowsFromDb // subflows query
-            return []
+            if (callCount === 1) {
+              return Promise.resolve(mockBlocksFromDb)
+            }
+            if (callCount === 2) {
+              return Promise.resolve(mockEdgesFromDb)
+            }
+            if (callCount === 3) {
+              return Promise.resolve(mockSubflowsFromDb)
+            }
+            return Promise.resolve([])
           }),
         }),
-      })
+      }))
 
       const result = await dbHelpers.loadWorkflowFromNormalizedTables(mockWorkflowId)
-
       expect(result).toBeDefined()
       expect(result?.isFromNormalizedTables).toBe(true)
       expect(result?.blocks).toBeDefined()
@@ -332,10 +341,10 @@ describe('Database Helpers', () => {
         from: vi.fn().mockReturnValue({
           where: vi.fn().mockImplementation(() => {
             callCount++
-            if (callCount === 1) return mockBlocksFromDb // blocks query
-            if (callCount === 2) return mockEdgesFromDb // edges query
-            if (callCount === 3) return subflowsWithUnknownType // subflows query
-            return []
+            if (callCount === 1) return Promise.resolve(mockBlocksFromDb) // blocks query
+            if (callCount === 2) return Promise.resolve(mockEdgesFromDb) // edges query
+            if (callCount === 3) return Promise.resolve(subflowsWithUnknownType) // subflows query
+            return Promise.resolve([])
           }),
         }),
       })
@@ -379,10 +388,10 @@ describe('Database Helpers', () => {
         from: vi.fn().mockReturnValue({
           where: vi.fn().mockImplementation(() => {
             callCount++
-            if (callCount === 1) return malformedBlocks // blocks query
-            if (callCount === 2) return [] // edges query
-            if (callCount === 3) return [] // subflows query
-            return []
+            if (callCount === 1) return Promise.resolve(malformedBlocks) // blocks query
+            if (callCount === 2) return Promise.resolve([]) // edges query
+            if (callCount === 3) return Promise.resolve([]) // subflows query
+            return Promise.resolve([])
           }),
         }),
       })
diff --git a/apps/sim/lib/workflows/db-helpers.ts b/apps/sim/lib/workflows/db-helpers.ts
index ccaea226469..a48454e81a6 100644
--- a/apps/sim/lib/workflows/db-helpers.ts
+++ b/apps/sim/lib/workflows/db-helpers.ts
@@ -2,7 +2,7 @@ import { eq } from 'drizzle-orm'
 import { createLogger } from '@/lib/logs/console-logger'
 import { db } from '@/db'
 import { workflowBlocks, workflowEdges, workflowSubflows } from '@/db/schema'
-import type { WorkflowState } from '@/stores/workflows/workflow/types'
+import type { LoopConfig, WorkflowState } from '@/stores/workflows/workflow/types'
 import { SUBFLOW_TYPES } from '@/stores/workflows/workflow/types'
 
 const logger = createLogger('WorkflowDBHelpers')
@@ -38,6 +38,17 @@ export async function loadWorkflowFromNormalizedTables(
     // Convert blocks to the expected format
     const blocksMap: Record<string, any> = {}
     blocks.forEach((block) => {
+      // Get parentId and extent from the database columns (primary source)
+      const parentId = block.parentId || null
+      const extent = block.extent || null
+
+      // Merge data with parent info for backward compatibility
+      const blockData = {
+        ...(block.data || {}),
+        ...(parentId && { parentId }),
+        ...(extent && { extent }),
+      }
+
       blocksMap[block.id] = {
         id: block.id,
         type: block.type,
@@ -52,9 +63,10 @@ export async function loadWorkflowFromNormalizedTables(
         height: Number(block.height),
         subBlocks: block.subBlocks || {},
         outputs: block.outputs || {},
-        data: block.data || {},
-        parentId: (block.data as any)?.parentId || null,
-        extent: (block.data as any)?.extent || null,
+        data: blockData,
+        // Set parentId and extent at the block level for ReactFlow
+        parentId,
+        extent,
       }
     })
 
@@ -75,15 +87,20 @@ export async function loadWorkflowFromNormalizedTables(
       const config = subflow.config || {}
 
       if (subflow.type === SUBFLOW_TYPES.LOOP) {
+        const loopConfig = config as LoopConfig
         loops[subflow.id] = {
           id: subflow.id,
           ...config,
         }
+        logger.debug(
+          `[DB-HELPERS] Loaded loop ${subflow.id} with iterations: ${loopConfig.iterations || 'unknown'}`
+        )
       } else if (subflow.type === SUBFLOW_TYPES.PARALLEL) {
         parallels[subflow.id] = {
           id: subflow.id,
           ...config,
         }
+        logger.debug(`[DB-HELPERS] Loaded parallel ${subflow.id}`)
       } else {
         logger.warn(`Unknown subflow type: ${subflow.type} for subflow ${subflow.id}`)
       }
diff --git a/apps/sim/next.config.ts b/apps/sim/next.config.ts
index d63bdd6eb3a..7876cc3d467 100644
--- a/apps/sim/next.config.ts
+++ b/apps/sim/next.config.ts
@@ -154,7 +154,7 @@ const nextConfig: NextConfig = {
           },
           {
             key: 'Content-Security-Policy',
-            value: `default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://*.google.com https://apis.google.com https://*.vercel-scripts.com https://*.vercel-insights.com https://vercel.live https://*.vercel.live https://vercel.com https://*.vercel.app; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data: blob: https://*.googleusercontent.com https://*.google.com https://*.atlassian.com https://cdn.discordapp.com https://*.githubusercontent.com; media-src 'self' blob:; font-src 'self' https://fonts.gstatic.com; connect-src 'self' ${process.env.NEXT_PUBLIC_APP_URL || ''} ${env.OLLAMA_URL || 'http://localhost:11434'} https://api.browser-use.com https://*.googleapis.com https://*.amazonaws.com https://*.s3.amazonaws.com https://*.blob.core.windows.net https://*.vercel-insights.com https://*.atlassian.com https://vercel.live https://*.vercel.live https://vercel.com https://*.vercel.app; frame-src https://drive.google.com https://*.google.com; frame-ancestors 'self'; form-action 'self'; base-uri 'self'; object-src 'none'`,
+            value: `default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://*.google.com https://apis.google.com https://*.vercel-scripts.com https://*.vercel-insights.com https://vercel.live https://*.vercel.live https://vercel.com https://*.vercel.app; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data: blob: https://*.googleusercontent.com https://*.google.com https://*.atlassian.com https://cdn.discordapp.com https://*.githubusercontent.com; media-src 'self' blob:; font-src 'self' https://fonts.gstatic.com; connect-src 'self' ${process.env.NEXT_PUBLIC_APP_URL || ''} ${env.OLLAMA_URL || 'http://localhost:11434'} ${process.env.NEXT_PUBLIC_SOCKET_URL || 'http://localhost:3002'} ${process.env.NEXT_PUBLIC_SOCKET_URL?.replace('http://', 'ws://').replace('https://', 'wss://') || 'ws://localhost:3002'} https://api.browser-use.com https://*.googleapis.com https://*.amazonaws.com https://*.s3.amazonaws.com https://*.blob.core.windows.net https://*.vercel-insights.com https://*.atlassian.com https://vercel.live https://*.vercel.live https://vercel.com https://*.vercel.app; frame-src https://drive.google.com https://*.google.com; frame-ancestors 'self'; form-action 'self'; base-uri 'self'; object-src 'none'`,
           },
         ],
       },
diff --git a/apps/sim/package.json b/apps/sim/package.json
index 05a35eaf844..3e9be45f578 100644
--- a/apps/sim/package.json
+++ b/apps/sim/package.json
@@ -11,6 +11,8 @@
   "scripts": {
     "dev": "next dev --turbo --port 3000",
     "dev:classic": "next dev",
+    "dev:sockets": "bun run socket-server/index.ts",
+    "dev:full": "concurrently \"bun run dev\" \"bun run dev:sockets\"",
     "build": "next build",
     "start": "next start",
     "prepare": "cd ../.. && bun husky",
@@ -104,6 +106,7 @@
     "reactflow": "^11.11.4",
     "recharts": "2.15.3",
     "resend": "^4.1.2",
+    "socket.io": "^4.8.1",
     "stripe": "^17.7.0",
     "tailwind-merge": "^2.6.0",
     "tailwindcss-animate": "^1.0.7",
@@ -125,6 +128,7 @@
     "@types/xlsx": "0.0.36",
     "@vitejs/plugin-react": "^4.3.4",
     "@vitest/coverage-v8": "^3.0.8",
+    "concurrently": "^9.1.0",
     "critters": "^0.0.23",
     "dotenv": "^16.4.7",
     "drizzle-kit": "^0.31.1",
diff --git a/apps/sim/providers/workspace-provider.tsx b/apps/sim/providers/workspace-provider.tsx
new file mode 100644
index 00000000000..9f176d89230
--- /dev/null
+++ b/apps/sim/providers/workspace-provider.tsx
@@ -0,0 +1,23 @@
+'use client'
+
+import type { ReactNode } from 'react'
+import { useSession } from '@/lib/auth-client'
+import { SocketProvider } from '@/contexts/socket-context'
+
+interface WorkspaceProviderProps {
+  children: ReactNode
+}
+
+export function WorkspaceProvider({ children }: WorkspaceProviderProps) {
+  const session = useSession()
+
+  const user = session.data?.user
+    ? {
+        id: session.data.user.id,
+        name: session.data.user.name,
+        email: session.data.user.email,
+      }
+    : undefined
+
+  return <SocketProvider user={user}>{children}</SocketProvider>
+}
diff --git a/apps/sim/scripts/insert-test-workflow.ts b/apps/sim/scripts/insert-test-workflow.ts
new file mode 100755
index 00000000000..8c215d4e6e2
--- /dev/null
+++ b/apps/sim/scripts/insert-test-workflow.ts
@@ -0,0 +1,168 @@
+#!/usr/bin/env bun
+
+import { db } from '../db'
+import { user, workflow, workspace } from '../db/schema'
+
+const testWorkflowState = {
+  blocks: {
+    'start-block-123': {
+      id: 'start-block-123',
+      type: 'starter',
+      name: 'Start',
+      position: {
+        x: 100,
+        y: 100,
+      },
+      subBlocks: {
+        startWorkflow: {
+          id: 'startWorkflow',
+          type: 'dropdown',
+          value: 'manual',
+        },
+      },
+      outputs: {
+        response: {
+          input: 'any',
+        },
+      },
+      enabled: true,
+      horizontalHandles: true,
+      isWide: false,
+      height: 90,
+    },
+    'loop-block-456': {
+      id: 'loop-block-456',
+      type: 'loop',
+      name: 'For Loop',
+      position: {
+        x: 400,
+        y: 100,
+      },
+      subBlocks: {},
+      outputs: {},
+      enabled: true,
+      horizontalHandles: true,
+      isWide: false,
+      height: 0,
+      data: {
+        width: 400,
+        height: 200,
+        type: 'loopNode',
+      },
+    },
+    'function-block-789': {
+      id: 'function-block-789',
+      type: 'function',
+      name: 'Return X',
+      position: {
+        x: 50,
+        y: 50,
+      },
+      subBlocks: {
+        code: {
+          id: 'code',
+          type: 'code',
+          value: "return 'X'",
+        },
+      },
+      outputs: {
+        response: {
+          result: 'any',
+          stdout: 'string',
+        },
+      },
+      enabled: true,
+      horizontalHandles: true,
+      isWide: false,
+      height: 144,
+      data: {
+        parentId: 'loop-block-456',
+        extent: 'parent',
+      },
+    },
+  },
+  edges: [
+    {
+      id: 'edge-start-to-loop',
+      source: 'start-block-123',
+      target: 'loop-block-456',
+      sourceHandle: 'source',
+      targetHandle: 'target',
+    },
+    {
+      id: 'edge-loop-to-function',
+      source: 'loop-block-456',
+      target: 'function-block-789',
+      sourceHandle: 'loop-start-source',
+      targetHandle: 'target',
+    },
+  ],
+  loops: {
+    'loop-block-456': {
+      id: 'loop-block-456',
+      nodes: ['function-block-789'],
+      iterations: 3,
+      loopType: 'for',
+      forEachItems: '',
+    },
+  },
+  parallels: {},
+  lastSaved: Date.now(),
+  isDeployed: false,
+}
+
+async function insertTestWorkflow() {
+  try {
+    console.log('🔍 Finding first workspace and user...')
+
+    // Get the first workspace
+    const workspaces = await db.select().from(workspace).limit(1)
+    if (workspaces.length === 0) {
+      throw new Error('No workspaces found. Please create a workspace first.')
+    }
+
+    // Get the first user
+    const users = await db.select().from(user).limit(1)
+    if (users.length === 0) {
+      throw new Error('No users found. Please create a user first.')
+    }
+
+    const workspaceId = workspaces[0].id
+    const userId = users[0].id
+    console.log(`✅ Using workspace: ${workspaceId}`)
+    console.log(`✅ Using user: ${userId}`)
+
+    // Insert workflow with old JSON state format
+    const testWorkflowId = `test-migration-workflow-${Date.now()}`
+
+    const now = new Date()
+
+    await db.insert(workflow).values({
+      id: testWorkflowId,
+      name: 'Test Migration Workflow (Old JSON Format)',
+      workspaceId: workspaceId,
+      userId: userId,
+      state: testWorkflowState, // This is the old JSON format
+      lastSynced: now,
+      createdAt: now,
+      updatedAt: now,
+      isDeployed: false,
+      isPublished: false,
+    })
+
+    console.log(`✅ Inserted test workflow with old JSON format: ${testWorkflowId}`)
+    console.log(`🌐 Access it at: http://localhost:3000/w/${testWorkflowId}`)
+    console.log('')
+    console.log('📋 Test steps:')
+    console.log('1. Open the workflow in your browser')
+    console.log('2. Verify it renders correctly with all blocks and connections')
+    console.log('3. Try editing some subblock values')
+    console.log('4. Run the migration script')
+    console.log('5. Verify it still works after migration')
+  } catch (error) {
+    console.error('❌ Error inserting test workflow:', error)
+    process.exit(1)
+  }
+}
+
+insertTestWorkflow()
diff --git a/apps/sim/scripts/migrate-workflow-states.ts b/apps/sim/scripts/migrate-workflow-states.ts
new file mode 100755
index 00000000000..9c8f2415894
--- /dev/null
+++ b/apps/sim/scripts/migrate-workflow-states.ts
@@ -0,0 +1,304 @@
+#!/usr/bin/env bun
+
+import { readFileSync } from 'fs'
+import { and, eq, inArray, isNotNull } from 'drizzle-orm'
+import { nanoid } from 'nanoid'
+import { db } from '../db'
+import { workflow, workflowBlocks, workflowEdges, workflowSubflows } from '../db/schema'
+
+interface WorkflowState {
+  blocks: Record<string, any>
+  edges: any[]
+  loops?: Record<string, any>
+  parallels?: Record<string, any>
+  lastSaved?: number
+  isDeployed?: boolean
+}
+
+async function migrateWorkflowStates(specificWorkflowIds?: string[] | null) {
+  try {
+    if (specificWorkflowIds) {
+      console.log(`🔍 Finding ${specificWorkflowIds.length} specific workflows...`)
+    } else {
+      console.log('🔍 Finding workflows with old JSON state format...')
+    }
+
+    // Build the where condition based on whether we have specific IDs
+    const whereCondition = specificWorkflowIds
+      ? and(
+          isNotNull(workflow.state), // Has JSON state
+          inArray(workflow.id, specificWorkflowIds) // Only specific IDs
+        )
+      : and(
+          isNotNull(workflow.state) // Has JSON state
+          // We'll check for normalized data existence per workflow
+        )
+
+    // Find workflows that have state but no normalized table entries
+    const workflowsToMigrate = await db
+      .select({
+        id: workflow.id,
+        name: workflow.name,
+        state: workflow.state,
+      })
+      .from(workflow)
+      .where(whereCondition)
+
+    console.log(`📊 Found ${workflowsToMigrate.length} workflows with JSON state`)
+
+    if (specificWorkflowIds) {
+      const foundIds = workflowsToMigrate.map((w) => w.id)
+      const missingIds = specificWorkflowIds.filter((id) => !foundIds.includes(id))
+      if (missingIds.length > 0) {
+        console.log(`⚠️  Warning: ${missingIds.length} specified workflow IDs not found:`)
+        missingIds.forEach((id) => console.log(`    - ${id}`))
+      }
+      console.log('')
+    }
+
+    let migratedCount = 0
+    let skippedCount = 0
+    let errorCount = 0
+
+    for (const wf of workflowsToMigrate) {
+      try {
+        // Check if this workflow already has normalized data
+        const existingBlocks = await db
+          .select({ id: workflowBlocks.id })
+          .from(workflowBlocks)
+          .where(eq(workflowBlocks.workflowId, wf.id))
+          .limit(1)
+
+        if (existingBlocks.length > 0) {
+          console.log(`⏭️  Skipping ${wf.name} (${wf.id}) - already has normalized data`)
+          skippedCount++
+          continue
+        }
+
+        console.log(`🔄 Migrating ${wf.name} (${wf.id})...`)
+
+        const state = wf.state as WorkflowState
+        if (!state || !state.blocks) {
+          console.log(`⚠️  Skipping ${wf.name} - invalid state format`)
+          skippedCount++
+          continue
+        }
+
+        // Clean up invalid blocks (those without an id field) before migration
+        const originalBlockCount = Object.keys(state.blocks).length
+        const validBlocks: Record<string, any> = {}
+        let removedBlockCount = 0
+
+        for (const [blockKey, block] of Object.entries(state.blocks)) {
+          if (block && typeof block === 'object' && block.id) {
+            // Valid block - has an id field
+            validBlocks[blockKey] = block
+          } else {
+            // Invalid block - missing id field
+            console.log(`    🗑️  Removing invalid block ${blockKey} (no id field)`)
+            removedBlockCount++
+          }
+        }
+
+        if (removedBlockCount > 0) {
+          console.log(
+            `    🧹 Cleaned up ${removedBlockCount} invalid blocks (${originalBlockCount} → ${Object.keys(validBlocks).length})`
+          )
+          state.blocks = validBlocks
+        }
+
+        await db.transaction(async (tx) => {
+          // Migrate blocks - generate new IDs and create mapping
+          const blocks = Object.values(state.blocks)
+          console.log(`  📦 Migrating ${blocks.length} blocks...`)
+
+          // Create mapping from old block IDs to new block IDs
+          const blockIdMapping: Record<string, string> = {}
+
+          for (const block of blocks) {
+            const newBlockId = nanoid()
+            blockIdMapping[block.id] = newBlockId
+
+            await tx.insert(workflowBlocks).values({
+              id: newBlockId,
+              workflowId: wf.id,
+              type: block.type,
+              name: block.name,
+              positionX: String(block.position?.x || 0),
+              positionY: String(block.position?.y || 0),
+              enabled: block.enabled ?? true,
+              horizontalHandles: block.horizontalHandles ?? true,
+              isWide: block.isWide ?? false,
+              height: String(block.height || 0),
+              subBlocks: block.subBlocks || {},
+              outputs: block.outputs || {},
+              data: block.data || {},
+              parentId: block.data?.parentId ? blockIdMapping[block.data.parentId] || null : null,
+            })
+          }
+
+          // Migrate edges - use new block IDs
+          const edges = state.edges || []
+          console.log(`  🔗 Migrating ${edges.length} edges...`)
+
+          for (const edge of edges) {
+            const newSourceId = blockIdMapping[edge.source]
+            const newTargetId = blockIdMapping[edge.target]
+
+            // Skip edges that reference blocks that don't exist in our mapping
+            if (!newSourceId || !newTargetId) {
+              console.log(`    ⚠️  Skipping edge ${edge.id} - references missing blocks`)
+              continue
+            }
+
+            await tx.insert(workflowEdges).values({
+              id: nanoid(),
+              workflowId: wf.id,
+              sourceBlockId: newSourceId,
+              targetBlockId: newTargetId,
+              sourceHandle: edge.sourceHandle || null,
+              targetHandle: edge.targetHandle || null,
+            })
+          }
+
+          // Migrate loops - update node IDs to use new block IDs
+          const loops = state.loops || {}
+          const loopIds = Object.keys(loops)
+          console.log(`  🔄 Migrating ${loopIds.length} loops...`)
+
+          for (const loopId of loopIds) {
+            const loop = loops[loopId]
+            // Map old node IDs to new block IDs
+            const updatedNodes = (loop.nodes || [])
+              .map((nodeId: string) => blockIdMapping[nodeId])
+              .filter(Boolean)
+
+            await tx.insert(workflowSubflows).values({
+              id: nanoid(),
+              workflowId: wf.id,
+              type: 'loop',
+              config: {
+                id: loop.id,
+                nodes: updatedNodes,
+                iterationCount: loop.iterations || 5,
+                iterationType: loop.loopType || 'for',
+                collection: loop.forEachItems || '',
+              },
+            })
+          }
+
+          // Migrate parallels - update node IDs to use new block IDs
+          const parallels = state.parallels || {}
+          const parallelIds = Object.keys(parallels)
+          console.log(`  ⚡ Migrating ${parallelIds.length} parallels...`)
+
+          for (const parallelId of parallelIds) {
+            const parallel = parallels[parallelId]
+            // Map old node IDs to new block IDs
+            const updatedNodes = (parallel.nodes || [])
+              .map((nodeId: string) => blockIdMapping[nodeId])
+              .filter(Boolean)
+
+            await tx.insert(workflowSubflows).values({
+              id: nanoid(),
+              workflowId: wf.id,
+              type: 'parallel',
+              config: {
+                id: parallel.id,
+                nodes: updatedNodes,
+                parallelCount: 2, // Default parallel count
+                collection: parallel.distribution || '',
+              },
+            })
+          }
+        })
+
+        console.log(`✅ Successfully migrated ${wf.name}`)
+        migratedCount++
+      } catch (error) {
+        console.error(`❌ Error migrating ${wf.name} (${wf.id}):`, error)
+        errorCount++
+      }
+    }
+
+    console.log('')
+    console.log('📊 Migration Summary:')
+    console.log(`✅ Migrated: ${migratedCount} workflows`)
+    console.log(`⏭️  Skipped: ${skippedCount} workflows`)
+    console.log(`❌ Errors: ${errorCount} workflows`)
+    console.log('')
+
+    if (migratedCount > 0) {
+      console.log('🎉 Migration completed successfully!')
+      console.log('')
+      console.log('📋 Next steps:')
+      console.log('1. Test the migrated workflows in your browser')
+      console.log('2. Verify all blocks, edges, and subflows work correctly')
+      console.log('3. Check that editing and collaboration still work')
+      console.log('4. Once confirmed, the workflow.state JSON field can be deprecated')
+    }
+  } catch (error) {
+    console.error('❌ Migration failed:', error)
+    process.exit(1)
+  }
+}
+
+// Add command line argument parsing
+const args = process.argv.slice(2)
+const dryRun = args.includes('--dry-run')
+const showHelp = args.includes('--help') || args.includes('-h')
+
+if (showHelp) {
+  console.log('🔄 Workflow State Migration Script')
+  console.log('')
+  console.log('Usage:')
+  console.log('  bun run scripts/migrate-workflow-states.ts [options]')
+  console.log('')
+  console.log('Options:')
+  console.log('  --dry-run              Show what would be migrated without making changes')
+  console.log('  --file <path>          Migrate only workflow IDs listed in file (comma-separated)')
+  console.log('  --help, -h             Show this help message')
+  console.log('')
+  console.log('Examples:')
+  console.log('  bun run scripts/migrate-workflow-states.ts')
+  console.log('  bun run scripts/migrate-workflow-states.ts --dry-run')
+  console.log('  bun run scripts/migrate-workflow-states.ts --file workflow-ids.txt')
+  console.log('  bun run scripts/migrate-workflow-states.ts --dry-run --file workflow-ids.txt')
+  console.log('')
+  console.log('File format (workflow-ids.txt):')
+  console.log('  abc-123,def-456,ghi-789')
+  console.log('')
+  process.exit(0)
+}
+
+// Parse --file flag for workflow IDs
+let specificWorkflowIds: string[] | null = null
+const fileIndex = args.findIndex((arg) => arg === '--file')
+if (fileIndex !== -1 && args[fileIndex + 1]) {
+  const filePath = args[fileIndex + 1]
+  try {
+    console.log(`📁 Reading workflow IDs from file: ${filePath}`)
+    const fileContent = readFileSync(filePath, 'utf-8')
+    specificWorkflowIds = fileContent
+      .split(',')
+      .map((id) => id.trim())
+      .filter((id) => id.length > 0)
+    console.log(`📋 Found ${specificWorkflowIds.length} workflow IDs in file`)
+    console.log('')
+  } catch (error) {
+    console.error(`❌ Error reading file ${filePath}:`, error)
+    process.exit(1)
+  }
+}
+
+if (dryRun) {
+  console.log('🔍 DRY RUN MODE - No changes will be made')
+  console.log('')
+}
+
+if (specificWorkflowIds) {
+  console.log('🎯 TARGETED MIGRATION - Only migrating specified workflow IDs')
+  console.log('')
+}
+
+migrateWorkflowStates(specificWorkflowIds)
diff --git a/apps/sim/serializer/types.ts b/apps/sim/serializer/types.ts
index fcf1d355a90..915f83631b9 100644
--- a/apps/sim/serializer/types.ts
+++ b/apps/sim/serializer/types.ts
@@ -52,4 +52,6 @@ export interface SerializedParallel {
   id: string
   nodes: string[]
   distribution?: any[] | Record<string, any> | string // Items to distribute or expression to evaluate
+  count?: number // Number of parallel executions for count-based parallel
+  parallelType?: 'count' | 'collection' // Explicit parallel type to avoid inference bugs
 }
diff --git a/apps/sim/socket-server/index.ts b/apps/sim/socket-server/index.ts
new file mode 100644
index 00000000000..36f1a2a11df
--- /dev/null
+++ b/apps/sim/socket-server/index.ts
@@ -0,0 +1,1881 @@
+import { createServer } from 'http'
+import { Server, type Socket } from 'socket.io'
+
+// Extend Socket interface to include user data
+interface AuthenticatedSocket extends Socket {
+  userId?: string
+  userName?: string
+  userEmail?: string
+  activeOrganizationId?: string
+}
+
+import { and, eq, isNull, or } from 'drizzle-orm'
+import { z } from 'zod'
+import { db } from '../db'
+import {
+  workflow,
+  workflowBlocks,
+  workflowEdges,
+  workflowSubflows,
+  workspaceMember,
+} from '../db/schema'
+import { auth } from '../lib/auth'
+import { createLogger } from '../lib/logs/console-logger'
+
+const logger = createLogger('CollaborativeSocketServer')
+
+// Enhanced server configuration
+const httpServer = createServer((req, res) => {
+  // Handle health check for Railway
+  if (req.method === 'GET' && req.url === '/health') {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(
+      JSON.stringify({
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+        connections: Array.from(workflowRooms.values()).reduce(
+          (total, room) => total + room.activeConnections,
+          0
+        ),
+      })
+    )
+    return
+  }
+
+  // Handle workflow deletion notifications from the main API
+  if (req.method === 'POST' && req.url === '/api/workflow-deleted') {
+    let body = ''
+    req.on('data', (chunk) => {
+      body += chunk.toString()
+    })
+    req.on('end', () => {
+      try {
+        const { workflowId } = JSON.parse(body)
+        handleWorkflowDeletion(workflowId)
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ success: true }))
+      } catch (error) {
+        logger.error('Error handling workflow deletion notification:', error)
+        res.writeHead(500, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ error: 'Failed to process deletion notification' }))
+      }
+    })
+    return
+  }
+
+  // Default response for other requests
+  res.writeHead(404, { 'Content-Type': 'application/json' })
+  res.end(JSON.stringify({ error: 'Not found' }))
+})
+
+// Configure allowed origins
+const allowedOrigins = [
+  process.env.NEXT_PUBLIC_APP_URL,
+  process.env.VERCEL_URL,
+  'http://localhost:3000',
+  'http://localhost:3001',
+  ...(process.env.ALLOWED_ORIGINS?.split(',') || []),
+].filter((url): url is string => Boolean(url))
+
+logger.info('Socket.IO CORS configuration:', { allowedOrigins })
+
+const io = new Server(httpServer, {
+  cors: {
+    origin: allowedOrigins,
+    methods: ['GET', 'POST', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization', 'Cookie', 'socket.io'],
+    credentials: true, // Enable credentials to accept cookies
+  },
+  transports: ['polling', 'websocket'],
+  allowEIO3: true,
+  pingTimeout: 60000,
+  pingInterval: 25000,
+  maxHttpBufferSize: 1e6,
+  cookie: {
+    name: 'io',
+    path: '/',
+    httpOnly: true,
+    sameSite: 'none', // Required for cross-origin cookies
+    secure: process.env.NODE_ENV === 'production', // HTTPS in production
+  },
+})
+
+// Enhanced connection and presence tracking
+interface UserPresence {
+  userId: string
+  workflowId: string
+  userName: string
+  socketId: string
+  joinedAt: number
+  lastActivity: number
+  cursor?: { x: number; y: number }
+  selection?: { type: 'block' | 'edge' | 'none'; id?: string }
+}
+
+interface WorkflowRoom {
+  workflowId: string
+  users: Map<string, UserPresence> // socketId -> UserPresence
+  lastModified: number
+  activeConnections: number
+}
+
+// Global state management
+const workflowRooms = new Map<string, WorkflowRoom>() // workflowId -> WorkflowRoom
+const socketToWorkflow = new Map<string, string>() // socketId -> workflowId
+const userSessions = new Map<string, { userId: string; userName: string }>() // socketId -> session
+
+// Enhanced database operation queue for batching and performance
+const pendingDbOperations = new Map<string, any[]>() // workflowId -> operations[]
+const batchTimeouts = new Map<string, NodeJS.Timeout>() // workflowId -> timeout
+const BATCH_DELAY = 100 // ms - batch operations within 100ms window
+const MAX_BATCH_SIZE = 50 // Maximum operations per batch
+
+// Validation schemas for workflow operations
+const PositionSchema = z.object({
+  x: z.number(),
+  y: z.number(),
+})
+
+const BlockOperationSchema = z.object({
+  operation: z.enum([
+    'add',
+    'remove',
+    'update-position',
+    'update-name',
+    'toggle-enabled',
+    'update-parent',
+    'duplicate',
+  ]),
+  target: z.literal('block'),
+  payload: z.object({
+    id: z.string(),
+    type: z.string().optional(),
+    name: z.string().optional(),
+    position: PositionSchema.optional(),
+    data: z.record(z.any()).optional(),
+    parentId: z.string().optional(),
+    extent: z.enum(['parent']).optional(),
+    enabled: z.boolean().optional(),
+  }),
+  timestamp: z.number(),
+})
+
+const EdgeOperationSchema = z.object({
+  operation: z.enum(['add', 'remove']),
+  target: z.literal('edge'),
+  payload: z.object({
+    id: z.string(),
+    source: z.string().optional(),
+    target: z.string().optional(),
+    sourceHandle: z.string().nullable().optional(),
+    targetHandle: z.string().nullable().optional(),
+  }),
+  timestamp: z.number(),
+})
+
+// Constants
+const DEFAULT_LOOP_ITERATIONS = 5
+
+// Enum for subflow types
+enum SubflowType {
+  LOOP = 'loop',
+  PARALLEL = 'parallel',
+}
+
+// Helper function to check if a block type is a subflow type
+function isSubflowBlockType(blockType: string): blockType is SubflowType {
+  return Object.values(SubflowType).includes(blockType as SubflowType)
+}
+
+// Helper function to update subflow node lists when child blocks are added/removed
+async function updateSubflowNodeList(dbOrTx: any, workflowId: string, parentId: string) {
+  try {
+    // Get all child blocks of this parent
+    const childBlocks = await dbOrTx
+      .select({ id: workflowBlocks.id })
+      .from(workflowBlocks)
+      .where(and(eq(workflowBlocks.workflowId, workflowId), eq(workflowBlocks.parentId, parentId)))
+
+    const childNodeIds = childBlocks.map((block: any) => block.id)
+
+    // Get current subflow config
+    const subflowData = await dbOrTx
+      .select({ config: workflowSubflows.config })
+      .from(workflowSubflows)
+      .where(and(eq(workflowSubflows.id, parentId), eq(workflowSubflows.workflowId, workflowId)))
+      .limit(1)
+
+    if (subflowData.length > 0) {
+      const updatedConfig = {
+        ...subflowData[0].config,
+        nodes: childNodeIds,
+      }
+
+      await dbOrTx
+        .update(workflowSubflows)
+        .set({
+          config: updatedConfig,
+          updatedAt: new Date(),
+        })
+        .where(and(eq(workflowSubflows.id, parentId), eq(workflowSubflows.workflowId, workflowId)))
+
+      logger.debug(`Updated subflow ${parentId} node list: [${childNodeIds.join(', ')}]`)
+    }
+  } catch (error) {
+    logger.error(`Error updating subflow node list for ${parentId}:`, error)
+  }
+}
+
+const SubflowOperationSchema = z.object({
+  operation: z.enum(['add', 'remove', 'update']),
+  target: z.literal('subflow'),
+  payload: z.object({
+    id: z.string(),
+    type: z.enum(['loop', 'parallel']).optional(),
+    config: z.record(z.any()).optional(),
+  }),
+  timestamp: z.number(),
+})
+
+const WorkflowOperationSchema = z.union([
+  BlockOperationSchema,
+  EdgeOperationSchema,
+  SubflowOperationSchema,
+])
+
+// Simplified conflict resolution - just last-write-wins since we have normalized tables
+function shouldAcceptOperation(operation: any, roomLastModified: number): boolean {
+  // Accept all operations - with normalized tables, conflicts are very unlikely
+  // We could add basic timestamp validation if needed, but for now just accept everything
+  return true
+}
+
+// Enhanced authentication middleware
+async function authenticateSocket(socket: AuthenticatedSocket, next: any) {
+  try {
+    // Extract authentication data from socket handshake
+    const token = socket.handshake.auth?.token
+    const origin = socket.handshake.headers.origin
+    const referer = socket.handshake.headers.referer
+
+    logger.info(`Socket ${socket.id} authentication attempt:`, {
+      hasToken: !!token,
+      origin,
+      referer,
+      allHeaders: Object.keys(socket.handshake.headers),
+    })
+
+    if (!token) {
+      logger.warn(`Socket ${socket.id} rejected: No authentication token found`)
+      return next(new Error('Authentication required'))
+    }
+
+    // Validate one-time token with Better Auth
+    try {
+      logger.debug(`Attempting token validation for socket ${socket.id}`, {
+        tokenLength: token?.length || 0,
+        origin,
+      })
+
+      const session = await auth.api.verifyOneTimeToken({
+        body: {
+          token,
+        },
+      })
+
+      if (!session?.user?.id) {
+        logger.warn(`Socket ${socket.id} rejected: Invalid token - no user found`)
+        return next(new Error('Invalid session'))
+      }
+
+      // Store user info in socket for later use
+      socket.userId = session.user.id
+      socket.userName = session.user.name || session.user.email || 'Unknown User'
+      socket.userEmail = session.user.email
+      socket.activeOrganizationId = session.session.activeOrganizationId || undefined
+
+      logger.info(`✅ Socket.IO user authenticated via token: ${socket.id}`, {
+        userId: session.user.id,
+        userName: socket.userName,
+        organizationId: socket.activeOrganizationId,
+        origin,
+      })
+      next()
+    } catch (tokenError) {
+      const errorMessage = tokenError instanceof Error ? tokenError.message : String(tokenError)
+      const errorStack = tokenError instanceof Error ? tokenError.stack : undefined
+
+      logger.warn(`Token validation failed for socket ${socket.id}:`, {
+        error: errorMessage,
+        stack: errorStack,
+        origin,
+        referer,
+      })
+      return next(new Error('Token validation failed'))
+    }
+  } catch (error) {
+    logger.error(`Socket authentication error for ${socket.id}:`, error)
+    next(new Error('Authentication failed'))
+  }
+}
+
+// Apply authentication middleware
+io.use(authenticateSocket)
+
+// Utility functions
+async function verifyWorkspaceMembership(
+  userId: string,
+  workspaceId: string
+): Promise<string | null> {
+  try {
+    const membership = await db
+      .select({ role: workspaceMember.role })
+      .from(workspaceMember)
+      .where(and(eq(workspaceMember.workspaceId, workspaceId), eq(workspaceMember.userId, userId)))
+      .limit(1)
+
+    return membership.length > 0 ? membership[0].role : null
+  } catch (error) {
+    logger.error(`Error verifying workspace membership for ${userId} in ${workspaceId}:`, error)
+    return null
+  }
+}
+async function verifyWorkflowAccess(
+  userId: string,
+  workflowId: string
+): Promise<{ hasAccess: boolean; role?: string; workspaceId?: string }> {
+  try {
+    const workflowData = await db
+      .select({
+        userId: workflow.userId,
+        workspaceId: workflow.workspaceId,
+        name: workflow.name,
+      })
+      .from(workflow)
+      .where(eq(workflow.id, workflowId))
+      .limit(1)
+
+    if (!workflowData.length) {
+      logger.warn(`Workflow ${workflowId} not found`)
+      return { hasAccess: false }
+    }
+
+    const { userId: workflowUserId, workspaceId, name: workflowName } = workflowData[0]
+
+    // Check if user owns the workflow
+    if (workflowUserId === userId) {
+      logger.debug(`User ${userId} has owner access to workflow ${workflowId} (${workflowName})`)
+      return { hasAccess: true, role: 'owner', workspaceId: workspaceId || undefined }
+    }
+
+    // Check workspace membership if workflow belongs to a workspace
+    if (workspaceId) {
+      const userRole = await verifyWorkspaceMembership(userId, workspaceId)
+      if (userRole) {
+        logger.debug(
+          `User ${userId} has ${userRole} access to workflow ${workflowId} via workspace ${workspaceId}`
+        )
+        return { hasAccess: true, role: userRole, workspaceId }
+      }
+      logger.warn(
+        `User ${userId} is not a member of workspace ${workspaceId} for workflow ${workflowId}`
+      )
+      return { hasAccess: false }
+    }
+
+    // Workflow doesn't belong to a workspace and user doesn't own it
+    logger.warn(`User ${userId} has no access to workflow ${workflowId} (no workspace, not owner)`)
+    return { hasAccess: false }
+  } catch (error) {
+    logger.error(
+      `Error verifying workflow access for user ${userId}, workflow ${workflowId}:`,
+      error
+    )
+    return { hasAccess: false }
+  }
+}
+
+// Enhanced authorization for specific operations
+async function verifyOperationPermission(
+  userId: string,
+  workflowId: string,
+  operation: string,
+  target: string
+): Promise<{ allowed: boolean; reason?: string }> {
+  try {
+    const accessInfo = await verifyWorkflowAccess(userId, workflowId)
+
+    if (!accessInfo.hasAccess) {
+      return { allowed: false, reason: 'No access to workflow' }
+    }
+
+    // Define operation permissions based on role
+    const rolePermissions = {
+      owner: [
+        'add',
+        'remove',
+        'update',
+        'update-position',
+        'update-name',
+        'toggle-enabled',
+        'update-parent',
+        'duplicate',
+      ],
+      admin: [
+        'add',
+        'remove',
+        'update',
+        'update-position',
+        'update-name',
+        'toggle-enabled',
+        'update-parent',
+        'duplicate',
+      ],
+      member: [
+        'add',
+        'remove',
+        'update',
+        'update-position',
+        'update-name',
+        'toggle-enabled',
+        'update-parent',
+        'duplicate',
+      ],
+      viewer: ['update-position'], // Viewers can only move things around
+    }
+
+    const allowedOperations = rolePermissions[accessInfo.role as keyof typeof rolePermissions] || []
+
+    if (!allowedOperations.includes(operation)) {
+      return {
+        allowed: false,
+        reason: `Role '${accessInfo.role}' not permitted to perform '${operation}' on '${target}'`,
+      }
+    }
+
+    return { allowed: true }
+  } catch (error) {
+    logger.error(`Error verifying operation permission:`, error)
+    return { allowed: false, reason: 'Permission check failed' }
+  }
+}
+
+function createWorkflowRoom(workflowId: string): WorkflowRoom {
+  return {
+    workflowId,
+    users: new Map(),
+    lastModified: Date.now(),
+    activeConnections: 0,
+  }
+}
+
+function cleanupUserFromRoom(socketId: string, workflowId: string) {
+  const room = workflowRooms.get(workflowId)
+  if (room) {
+    room.users.delete(socketId)
+    room.activeConnections = Math.max(0, room.activeConnections - 1)
+
+    if (room.activeConnections === 0) {
+      workflowRooms.delete(workflowId)
+      logger.info(`Cleaned up empty workflow room: ${workflowId}`)
+    }
+  }
+
+  socketToWorkflow.delete(socketId)
+  userSessions.delete(socketId)
+}
+
+function clearPendingOperations(socketId: string) {
+  // Clear any pending operations for this socket
+  // This would be used if we implement operation queuing
+  logger.debug(`Cleared pending operations for socket ${socketId}`)
+}
+
+// Handle workflow deletion notifications
+function handleWorkflowDeletion(workflowId: string) {
+  logger.info(`Handling workflow deletion notification for ${workflowId}`)
+
+  const room = workflowRooms.get(workflowId)
+  if (!room) {
+    logger.debug(`No active room found for deleted workflow ${workflowId}`)
+    return
+  }
+
+  // Notify all users in the room that the workflow has been deleted
+  io.to(workflowId).emit('workflow-deleted', {
+    workflowId,
+    message: 'This workflow has been deleted',
+    timestamp: Date.now(),
+  })
+
+  // Disconnect all sockets from the workflow room
+  const socketsToDisconnect: string[] = []
+  room.users.forEach((presence, socketId) => {
+    socketsToDisconnect.push(socketId)
+  })
+
+  // Clean up each socket connection
+  socketsToDisconnect.forEach((socketId) => {
+    const socket = io.sockets.sockets.get(socketId)
+    if (socket) {
+      socket.leave(workflowId)
+      logger.debug(`Disconnected socket ${socketId} from deleted workflow ${workflowId}`)
+    }
+    cleanupUserFromRoom(socketId, workflowId)
+  })
+
+  // Clean up the room completely
+  workflowRooms.delete(workflowId)
+  logger.info(
+    `Cleaned up workflow room ${workflowId} after deletion (${socketsToDisconnect.length} users disconnected)`
+  )
+}
+
+// Database helper functions
+async function getWorkflowState(workflowId: string) {
+  try {
+    const workflowData = await db
+      .select()
+      .from(workflow)
+      .where(eq(workflow.id, workflowId))
+      .limit(1)
+
+    if (!workflowData.length) {
+      throw new Error(`Workflow ${workflowId} not found`)
+    }
+
+    return {
+      ...workflowData[0],
+      lastModified: Date.now(),
+    }
+  } catch (error) {
+    logger.error(`Error fetching workflow state for ${workflowId}:`, error)
+    throw error
+  }
+}
+
+async function persistWorkflowOperation(workflowId: string, operation: any) {
+  // Use database transaction for consistency
+  try {
+    const { operation: op, target, payload, timestamp, userId } = operation
+
+    await db.transaction(async (tx) => {
+      // Update the workflow's last modified timestamp first
+      await tx
+        .update(workflow)
+        .set({ updatedAt: new Date(timestamp) })
+        .where(eq(workflow.id, workflowId))
+
+      // Handle different operation types within the transaction
+      switch (target) {
+        case 'block':
+          await handleBlockOperationTx(tx, workflowId, op, payload, userId)
+          break
+        case 'edge':
+          await handleEdgeOperationTx(tx, workflowId, op, payload, userId)
+          break
+        case 'subflow':
+          await handleSubflowOperationTx(tx, workflowId, op, payload, userId)
+          break
+        default:
+          throw new Error(`Unknown operation target: ${target}`)
+      }
+    })
+
+    logger.debug(`✅ Persisted ${op} operation on ${target} for workflow ${workflowId}`)
+  } catch (error) {
+    logger.error(
+      `❌ Error persisting workflow operation (${operation.operation} on ${operation.target}):`,
+      error
+    )
+    throw error
+  }
+}
+
+// Add data consistency validation
+async function validateWorkflowConsistency(
+  workflowId: string
+): Promise<{ valid: boolean; issues: string[] }> {
+  try {
+    const issues: string[] = []
+
+    // Check for orphaned edges (edges pointing to non-existent blocks)
+    const orphanedEdges = await db
+      .select({
+        id: workflowEdges.id,
+        sourceBlockId: workflowEdges.sourceBlockId,
+        targetBlockId: workflowEdges.targetBlockId,
+      })
+      .from(workflowEdges)
+      .leftJoin(workflowBlocks, eq(workflowEdges.sourceBlockId, workflowBlocks.id))
+      .where(
+        and(
+          eq(workflowEdges.workflowId, workflowId),
+          isNull(workflowBlocks.id) // Source block doesn't exist
+        )
+      )
+
+    if (orphanedEdges.length > 0) {
+      issues.push(`Found ${orphanedEdges.length} orphaned edges with missing source blocks`)
+    }
+
+    // Could add more consistency checks here as needed
+
+    return { valid: issues.length === 0, issues }
+  } catch (error) {
+    logger.error('Error validating workflow consistency:', error)
+    return { valid: false, issues: ['Consistency check failed'] }
+  }
+}
+
+// Transaction-based operation handlers for data consistency
+async function handleBlockOperationTx(
+  tx: any,
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  return handleBlockOperationImpl(tx, workflowId, operation, payload, userId)
+}
+
+async function handleEdgeOperationTx(
+  tx: any,
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  return handleEdgeOperationImpl(tx, workflowId, operation, payload, userId)
+}
+
+async function handleSubflowOperationTx(
+  tx: any,
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  return handleSubflowOperationImpl(tx, workflowId, operation, payload, userId)
+}
+
+// Implementation functions that work with both db and transaction
+async function handleEdgeOperationImpl(
+  dbOrTx: any,
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  // Move the existing handleEdgeOperation logic here
+  return handleEdgeOperation(workflowId, operation, payload, userId)
+}
+
+async function handleSubflowOperationImpl(
+  dbOrTx: any,
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  try {
+    switch (operation) {
+      case 'add':
+        // Validate required fields
+        if (!payload.id || !payload.type || !payload.config) {
+          throw new Error('Missing required fields for add subflow operation')
+        }
+
+        // Validate subflow type
+        if (!['loop', 'parallel'].includes(payload.type)) {
+          throw new Error(`Invalid subflow type: ${payload.type}`)
+        }
+
+        // Validate config structure based on type
+        if (payload.type === 'loop') {
+          if (!payload.config.nodes || !Array.isArray(payload.config.nodes)) {
+            throw new Error('Loop subflow requires nodes array in config')
+          }
+          if (!payload.config.loopType || !['for', 'forEach'].includes(payload.config.loopType)) {
+            throw new Error('Loop subflow requires valid loopType (for or forEach)')
+          }
+        } else if (payload.type === 'parallel') {
+          if (!payload.config.nodes || !Array.isArray(payload.config.nodes)) {
+            throw new Error('Parallel subflow requires nodes array in config')
+          }
+        }
+
+        await dbOrTx.insert(workflowSubflows).values({
+          id: payload.id,
+          workflowId,
+          type: payload.type,
+          config: payload.config,
+        })
+
+        logger.debug(`Added ${payload.type} subflow ${payload.id} to workflow ${workflowId}`)
+        break
+
+      case 'update': {
+        if (!payload.id || !payload.config) {
+          throw new Error('Missing required fields for update subflow operation')
+        }
+
+        logger.debug(`[SERVER] Updating subflow ${payload.id} with config:`, payload.config)
+
+        // Update the subflow configuration
+        const updateResult = await dbOrTx
+          .update(workflowSubflows)
+          .set({
+            config: payload.config,
+            updatedAt: new Date(),
+          })
+          .where(
+            and(eq(workflowSubflows.id, payload.id), eq(workflowSubflows.workflowId, workflowId))
+          )
+          .returning({ id: workflowSubflows.id })
+
+        if (updateResult.length === 0) {
+          throw new Error(`Subflow ${payload.id} not found in workflow ${workflowId}`)
+        }
+
+        // Also update the corresponding block's data to keep UI in sync
+        if (payload.type === 'loop' && payload.config.iterations !== undefined) {
+          // Update the loop block's data.count property
+          await dbOrTx
+            .update(workflowBlocks)
+            .set({
+              data: {
+                ...payload.config,
+                count: payload.config.iterations,
+                loopType: payload.config.loopType,
+                collection: payload.config.forEachItems,
+                width: 500,
+                height: 300,
+                type: 'loopNode',
+              },
+              updatedAt: new Date(),
+            })
+            .where(
+              and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId))
+            )
+
+          logger.debug(
+            `[SERVER] ✅ Also updated loop block ${payload.id} data.count = ${payload.config.iterations}`
+          )
+        } else if (payload.type === 'parallel') {
+          // Update the parallel block's data properties
+          const blockData = {
+            ...payload.config,
+            width: 500,
+            height: 300,
+            type: 'parallelNode',
+          }
+
+          // Include count if provided
+          if (payload.config.count !== undefined) {
+            blockData.count = payload.config.count
+          }
+
+          // Include collection if provided
+          if (payload.config.distribution !== undefined) {
+            blockData.collection = payload.config.distribution
+          }
+
+          // Include parallelType if provided
+          if (payload.config.parallelType !== undefined) {
+            blockData.parallelType = payload.config.parallelType
+          }
+
+          await dbOrTx
+            .update(workflowBlocks)
+            .set({
+              data: blockData,
+              updatedAt: new Date(),
+            })
+            .where(
+              and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId))
+            )
+
+          logger.debug(`[SERVER] ✅ Also updated parallel block ${payload.id} data:`, {
+            count: payload.config.count,
+            collection: payload.config.distribution,
+            parallelType: payload.config.parallelType,
+          })
+        }
+
+        logger.debug(
+          `[SERVER] ✅ Successfully updated subflow ${payload.id} in workflow ${workflowId}`
+        )
+        break
+      }
+
+      case 'remove': {
+        if (!payload.id) {
+          throw new Error('Missing subflow ID for remove operation')
+        }
+
+        const deleteResult = await dbOrTx
+          .delete(workflowSubflows)
+          .where(
+            and(eq(workflowSubflows.id, payload.id), eq(workflowSubflows.workflowId, workflowId))
+          )
+          .returning({ id: workflowSubflows.id })
+
+        if (deleteResult.length === 0) {
+          throw new Error(`Subflow ${payload.id} not found in workflow ${workflowId}`)
+        }
+
+        logger.debug(`Removed subflow ${payload.id} from workflow ${workflowId}`)
+        break
+      }
+
+      default:
+        logger.warn(`Unknown subflow operation: ${operation}`)
+        throw new Error(`Unsupported subflow operation: ${operation}`)
+    }
+  } catch (error) {
+    logger.error(`Error in handleSubflowOperation (${operation}):`, error)
+    throw error
+  }
+}
+
+// Enhanced operation handlers with comprehensive validation
+async function handleBlockOperation(
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  return handleBlockOperationImpl(db, workflowId, operation, payload, userId)
+}
+
+async function handleBlockOperationImpl(
+  dbOrTx: any,
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  try {
+    switch (operation) {
+      case 'add': {
+        // Validate required fields for add operation
+        if (!payload.id || !payload.type || !payload.name || !payload.position) {
+          throw new Error('Missing required fields for add block operation')
+        }
+
+        logger.debug(`[SERVER] Adding block: ${payload.type} (${payload.id})`, {
+          isSubflowType: isSubflowBlockType(payload.type),
+          payload,
+        })
+
+        // Extract parentId and extent from payload.data if they exist there, otherwise from payload directly
+        const parentId = payload.parentId || payload.data?.parentId || null
+        const extent = payload.extent || payload.data?.extent || null
+
+        logger.debug(`[SERVER] Block parent info:`, {
+          blockId: payload.id,
+          hasParent: !!parentId,
+          parentId,
+          extent,
+          payloadParentId: payload.parentId,
+          dataParentId: payload.data?.parentId,
+        })
+
+        await dbOrTx.insert(workflowBlocks).values({
+          id: payload.id,
+          workflowId,
+          type: payload.type,
+          name: payload.name,
+          positionX: payload.position.x,
+          positionY: payload.position.y,
+          data: payload.data || {},
+          parentId,
+          extent,
+          enabled: true, // Default to enabled
+        })
+
+        // Auto-create subflow entry for loop/parallel blocks
+        if (isSubflowBlockType(payload.type)) {
+          try {
+            const subflowConfig =
+              payload.type === SubflowType.LOOP
+                ? {
+                    id: payload.id,
+                    nodes: [], // Empty initially, will be populated when child blocks are added
+                    iterations: payload.data?.count || DEFAULT_LOOP_ITERATIONS,
+                    loopType: payload.data?.loopType || 'for',
+                    forEachItems: payload.data?.collection || '',
+                  }
+                : {
+                    id: payload.id,
+                    nodes: [], // Empty initially, will be populated when child blocks are added
+                    distribution: payload.data?.collection || '',
+                  }
+
+            logger.debug(
+              `[SERVER] Auto-creating ${payload.type} subflow ${payload.id}:`,
+              subflowConfig
+            )
+
+            await dbOrTx.insert(workflowSubflows).values({
+              id: payload.id,
+              workflowId,
+              type: payload.type,
+              config: subflowConfig,
+            })
+
+            logger.debug(`[SERVER] ✅ Successfully created ${payload.type} subflow ${payload.id}`)
+          } catch (subflowError) {
+            logger.error(
+              `[SERVER] ❌ Failed to create ${payload.type} subflow ${payload.id}:`,
+              subflowError
+            )
+            throw subflowError
+          }
+        }
+
+        // If this block has a parent, update the parent's subflow node list
+        if (parentId) {
+          await updateSubflowNodeList(dbOrTx, workflowId, parentId)
+        }
+
+        logger.debug(`Added block ${payload.id} (${payload.type}) to workflow ${workflowId}`)
+        break
+      }
+
+      case 'update-position': {
+        if (!payload.id || !payload.position) {
+          throw new Error('Missing required fields for update position operation')
+        }
+
+        const updateResult = await dbOrTx
+          .update(workflowBlocks)
+          .set({
+            positionX: payload.position.x,
+            positionY: payload.position.y,
+            updatedAt: new Date(),
+          })
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+          .returning({ id: workflowBlocks.id })
+
+        if (updateResult.length === 0) {
+          throw new Error(`Block ${payload.id} not found in workflow ${workflowId}`)
+        }
+        break
+      }
+
+      case 'update-name':
+        if (!payload.id || !payload.name) {
+          throw new Error('Missing required fields for update name operation')
+        }
+
+        await db
+          .update(workflowBlocks)
+          .set({
+            name: payload.name,
+            updatedAt: new Date(),
+          })
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+        break
+
+      case 'update-parent': {
+        if (!payload.id) {
+          throw new Error('Missing block ID for update parent operation')
+        }
+
+        // Get the current parent before updating
+        const currentBlock = await dbOrTx
+          .select({ parentId: workflowBlocks.parentId })
+          .from(workflowBlocks)
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+          .limit(1)
+
+        const oldParentId = currentBlock.length > 0 ? currentBlock[0].parentId : null
+
+        await dbOrTx
+          .update(workflowBlocks)
+          .set({
+            parentId: payload.parentId || null,
+            extent: payload.extent || null,
+            updatedAt: new Date(),
+          })
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+
+        // Update subflow node lists for both old and new parents
+        if (oldParentId) {
+          await updateSubflowNodeList(dbOrTx, workflowId, oldParentId)
+        }
+        if (payload.parentId && payload.parentId !== oldParentId) {
+          await updateSubflowNodeList(dbOrTx, workflowId, payload.parentId)
+        }
+        break
+      }
+
+      case 'remove': {
+        if (!payload.id) {
+          throw new Error('Missing block ID for remove operation')
+        }
+
+        // Check if this is a subflow block that needs cascade deletion
+        const blockToRemove = await dbOrTx
+          .select({ type: workflowBlocks.type, parentId: workflowBlocks.parentId })
+          .from(workflowBlocks)
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+          .limit(1)
+
+        if (blockToRemove.length > 0 && isSubflowBlockType(blockToRemove[0].type)) {
+          // Cascade delete: Remove all child blocks first
+          const childBlocks = await dbOrTx
+            .select({ id: workflowBlocks.id, type: workflowBlocks.type })
+            .from(workflowBlocks)
+            .where(
+              and(
+                eq(workflowBlocks.workflowId, workflowId),
+                eq(workflowBlocks.parentId, payload.id)
+              )
+            )
+
+          logger.debug(
+            `[SERVER] Starting cascade deletion for subflow block ${payload.id} (type: ${blockToRemove[0].type})`
+          )
+          logger.debug(
+            `[SERVER] Found ${childBlocks.length} child blocks to delete: [${childBlocks.map((b: any) => `${b.id} (${b.type})`).join(', ')}]`
+          )
+
+          // Remove edges connected to child blocks
+          for (const childBlock of childBlocks) {
+            await dbOrTx
+              .delete(workflowEdges)
+              .where(
+                and(
+                  eq(workflowEdges.workflowId, workflowId),
+                  or(
+                    eq(workflowEdges.sourceBlockId, childBlock.id),
+                    eq(workflowEdges.targetBlockId, childBlock.id)
+                  )
+                )
+              )
+          }
+
+          // Remove child blocks from database
+          await dbOrTx
+            .delete(workflowBlocks)
+            .where(
+              and(
+                eq(workflowBlocks.workflowId, workflowId),
+                eq(workflowBlocks.parentId, payload.id)
+              )
+            )
+
+          // Remove the subflow entry
+          await dbOrTx
+            .delete(workflowSubflows)
+            .where(
+              and(eq(workflowSubflows.id, payload.id), eq(workflowSubflows.workflowId, workflowId))
+            )
+
+          logger.debug(
+            `[SERVER] ✅ Cascade deleted ${childBlocks.length} child blocks and subflow ${payload.id}`
+          )
+        }
+
+        // Remove any edges connected to this block
+        await dbOrTx
+          .delete(workflowEdges)
+          .where(
+            and(
+              eq(workflowEdges.workflowId, workflowId),
+              or(
+                eq(workflowEdges.sourceBlockId, payload.id),
+                eq(workflowEdges.targetBlockId, payload.id)
+              )
+            )
+          )
+
+        // Finally remove the block itself
+        await dbOrTx
+          .delete(workflowBlocks)
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+
+        // If this block had a parent, update the parent's subflow node list
+        if (blockToRemove.length > 0 && blockToRemove[0].parentId) {
+          await updateSubflowNodeList(dbOrTx, workflowId, blockToRemove[0].parentId)
+        }
+
+        logger.debug(`Removed block ${payload.id} and its connections from workflow ${workflowId}`)
+        break
+      }
+
+      case 'toggle-enabled':
+        if (!payload.id || payload.enabled === undefined) {
+          throw new Error('Missing required fields for toggle enabled operation')
+        }
+
+        await db
+          .update(workflowBlocks)
+          .set({
+            enabled: payload.enabled,
+            updatedAt: new Date(),
+          })
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+        break
+
+      case 'duplicate': {
+        if (!payload.id || !payload.newId || !payload.position) {
+          throw new Error('Missing required fields for duplicate operation')
+        }
+
+        // Get the original block
+        const originalBlock = await db
+          .select()
+          .from(workflowBlocks)
+          .where(and(eq(workflowBlocks.id, payload.id), eq(workflowBlocks.workflowId, workflowId)))
+          .limit(1)
+
+        if (originalBlock.length === 0) {
+          throw new Error(`Original block ${payload.id} not found`)
+        }
+
+        // Create duplicate with new ID and position
+        await db.insert(workflowBlocks).values({
+          ...originalBlock[0],
+          id: payload.newId,
+          name: `${originalBlock[0].name} (Copy)`,
+          positionX: payload.position.x,
+          positionY: payload.position.y,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        })
+        break
+      }
+
+      default:
+        logger.warn(`Unknown block operation: ${operation}`)
+        throw new Error(`Unsupported block operation: ${operation}`)
+    }
+  } catch (error) {
+    logger.error(`Error in handleBlockOperation (${operation}):`, error)
+    throw error
+  }
+}
+
+async function handleEdgeOperation(
+  workflowId: string,
+  operation: string,
+  payload: any,
+  userId: string
+) {
+  try {
+    switch (operation) {
+      case 'add': {
+        // Validate required fields
+        if (!payload.id || !payload.source || !payload.target) {
+          throw new Error('Missing required fields for add edge operation')
+        }
+
+        // Check if source and target blocks exist
+        const sourceBlock = await db
+          .select({ id: workflowBlocks.id })
+          .from(workflowBlocks)
+          .where(
+            and(eq(workflowBlocks.id, payload.source), eq(workflowBlocks.workflowId, workflowId))
+          )
+          .limit(1)
+
+        const targetBlock = await db
+          .select({ id: workflowBlocks.id })
+          .from(workflowBlocks)
+          .where(
+            and(eq(workflowBlocks.id, payload.target), eq(workflowBlocks.workflowId, workflowId))
+          )
+          .limit(1)
+
+        if (sourceBlock.length === 0) {
+          // For new workflows, blocks might not be persisted yet - log warning but don't fail
+          logger.warn(
+            `Source block ${payload.source} not found in database - may be a new workflow`
+          )
+          throw new Error(`Source block ${payload.source} not found`)
+        }
+        if (targetBlock.length === 0) {
+          logger.warn(
+            `Target block ${payload.target} not found in database - may be a new workflow`
+          )
+          throw new Error(`Target block ${payload.target} not found`)
+        }
+
+        // Check for duplicate edges
+        const existingEdge = await db
+          .select({ id: workflowEdges.id })
+          .from(workflowEdges)
+          .where(
+            and(
+              eq(workflowEdges.workflowId, workflowId),
+              eq(workflowEdges.sourceBlockId, payload.source),
+              eq(workflowEdges.targetBlockId, payload.target),
+              eq(workflowEdges.sourceHandle, payload.sourceHandle || ''),
+              eq(workflowEdges.targetHandle, payload.targetHandle || '')
+            )
+          )
+          .limit(1)
+
+        if (existingEdge.length > 0) {
+          logger.warn(`Duplicate edge detected: ${payload.source} -> ${payload.target}`)
+          return // Skip duplicate edge creation
+        }
+
+        await db.insert(workflowEdges).values({
+          id: payload.id,
+          workflowId,
+          sourceBlockId: payload.source,
+          targetBlockId: payload.target,
+          sourceHandle: payload.sourceHandle || null,
+          targetHandle: payload.targetHandle || null,
+        })
+
+        logger.debug(`Added edge ${payload.id}: ${payload.source} -> ${payload.target}`)
+        break
+      }
+
+      case 'remove': {
+        if (!payload.id) {
+          throw new Error('Missing edge ID for remove operation')
+        }
+
+        const deleteResult = await db
+          .delete(workflowEdges)
+          .where(and(eq(workflowEdges.id, payload.id), eq(workflowEdges.workflowId, workflowId)))
+          .returning({ id: workflowEdges.id })
+
+        if (deleteResult.length === 0) {
+          throw new Error(`Edge ${payload.id} not found in workflow ${workflowId}`)
+        }
+
+        logger.debug(`Removed edge ${payload.id} from workflow ${workflowId}`)
+        break
+      }
+
+      default:
+        logger.warn(`Unknown edge operation: ${operation}`)
+        throw new Error(`Unsupported edge operation: ${operation}`)
+    }
+  } catch (error) {
+    logger.error(`Error in handleEdgeOperation (${operation}):`, error)
+    throw error
+  }
+}
+
+// Global error handling
+process.on('uncaughtException', (error) => {
+  logger.error('Uncaught Exception:', error)
+  // Don't exit in production, just log
+})
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.error('Unhandled Rejection at:', promise, 'reason:', reason)
+})
+
+// Socket server error handling
+httpServer.on('error', (error) => {
+  logger.error('HTTP server error:', error)
+})
+
+io.engine.on('connection_error', (err) => {
+  logger.error('Socket.IO connection error:', {
+    req: err.req?.url,
+    code: err.code,
+    message: err.message,
+    context: err.context,
+  })
+})
+
+io.on('connection', (socket: AuthenticatedSocket) => {
+  logger.info(`✅ Socket.IO user connected: ${socket.id}`, {
+    transport: socket.conn.transport.name,
+    remoteAddress: socket.conn.remoteAddress,
+    userId: socket.userId,
+    userName: socket.userName,
+  })
+
+  // Set up error handling for this socket
+  socket.on('error', (error) => {
+    logger.error(`Socket ${socket.id} error:`, error)
+  })
+
+  socket.conn.on('error', (error) => {
+    logger.error(`Socket ${socket.id} connection error:`, error)
+  })
+
+  // Handle joining a workflow room with enhanced authentication
+  socket.on('join-workflow', async ({ workflowId }) => {
+    try {
+      // Use authenticated user info from socket
+      const userId = socket.userId
+      const userName = socket.userName
+
+      if (!userId || !userName) {
+        logger.warn(`Join workflow rejected: Socket ${socket.id} not authenticated`)
+        socket.emit('join-workflow-error', { error: 'Authentication required' })
+        return
+      }
+
+      logger.info(`Join workflow request from ${userId} (${userName}) for workflow ${workflowId}`)
+
+      // Verify workflow access
+      try {
+        const accessInfo = await verifyWorkflowAccess(userId, workflowId)
+        if (!accessInfo.hasAccess) {
+          logger.warn(`User ${userId} (${userName}) denied access to workflow ${workflowId}`)
+          socket.emit('join-workflow-error', { error: 'Access denied to workflow' })
+          return
+        }
+      } catch (error) {
+        logger.warn(`Error verifying workflow access for ${userId}:`, error)
+        socket.emit('join-workflow-error', { error: 'Failed to verify workflow access' })
+        return
+      }
+
+      // Leave any previous workflow room
+      const currentWorkflowId = socketToWorkflow.get(socket.id)
+      if (currentWorkflowId) {
+        socket.leave(currentWorkflowId)
+        cleanupUserFromRoom(socket.id, currentWorkflowId)
+
+        // Notify previous room about user leaving
+        socket.to(currentWorkflowId).emit('user-left', {
+          userId,
+          socketId: socket.id,
+        })
+      }
+
+      // Join the new workflow room
+      socket.join(workflowId)
+
+      // Create or get workflow room
+      if (!workflowRooms.has(workflowId)) {
+        workflowRooms.set(workflowId, createWorkflowRoom(workflowId))
+      }
+
+      const room = workflowRooms.get(workflowId)!
+      room.activeConnections++
+
+      // Store user presence
+      const userPresence: UserPresence = {
+        userId,
+        workflowId,
+        userName,
+        socketId: socket.id,
+        joinedAt: Date.now(),
+        lastActivity: Date.now(),
+      }
+
+      room.users.set(socket.id, userPresence)
+      socketToWorkflow.set(socket.id, workflowId)
+      userSessions.set(socket.id, { userId, userName })
+
+      // Get current room presence for the new user
+      const roomPresence = Array.from(room.users.values())
+
+      // Send current workflow state and presence to the new user
+      const workflowState = await getWorkflowState(workflowId)
+      socket.emit('workflow-state', workflowState)
+      socket.emit('presence-update', roomPresence)
+
+      // Notify others in the room about new user
+      socket.to(workflowId).emit('user-joined', {
+        userId,
+        userName,
+        socketId: socket.id,
+      })
+
+      logger.info(
+        `User ${userId} (${userName}) joined workflow ${workflowId}. Room now has ${room.activeConnections} users.`
+      )
+    } catch (error) {
+      logger.error('Error joining workflow:', error)
+      socket.emit('error', {
+        type: 'JOIN_ERROR',
+        message: 'Failed to join workflow',
+      })
+    }
+  })
+
+  // Handle workflow operations (blocks, edges, subflows) with enhanced validation and conflict resolution
+  socket.on('workflow-operation', async (data) => {
+    const workflowId = socketToWorkflow.get(socket.id)
+    const session = userSessions.get(socket.id)
+
+    if (!workflowId || !session) {
+      socket.emit('error', {
+        type: 'NOT_JOINED',
+        message: 'Not joined to any workflow',
+      })
+      return
+    }
+
+    const room = workflowRooms.get(workflowId)
+    if (!room) {
+      socket.emit('error', {
+        type: 'ROOM_NOT_FOUND',
+        message: 'Workflow room not found',
+      })
+      return
+    }
+
+    try {
+      // Validate operation schema
+      const validatedOperation = WorkflowOperationSchema.parse(data)
+      const { operation, target, payload, timestamp } = validatedOperation
+
+      // Check if operation should be accepted (simplified conflict resolution)
+      if (!shouldAcceptOperation(validatedOperation, room.lastModified)) {
+        socket.emit('operation-rejected', {
+          type: 'OPERATION_REJECTED',
+          message: 'Operation rejected',
+          operation,
+          target,
+          serverTimestamp: Date.now(),
+        })
+        return
+      }
+
+      // Check operation permissions (temporarily bypassed for testing)
+      const permissionCheck = await verifyOperationPermission(
+        session.userId,
+        workflowId,
+        operation,
+        target
+      )
+      if (!permissionCheck.allowed) {
+        logger.warn(
+          `User ${session.userId} forbidden from ${operation} on ${target}: ${permissionCheck.reason}`
+        )
+        socket.emit('operation-forbidden', {
+          type: 'INSUFFICIENT_PERMISSIONS',
+          message: permissionCheck.reason || 'Insufficient permissions for this operation',
+          operation,
+          target,
+        })
+        return
+      }
+
+      // Update user activity
+      const userPresence = room.users.get(socket.id)
+      if (userPresence) {
+        userPresence.lastActivity = Date.now()
+      }
+
+      // Persist to database with transaction (last-write-wins)
+      const serverTimestamp = Date.now()
+      await persistWorkflowOperation(workflowId, {
+        operation,
+        target,
+        payload,
+        timestamp: serverTimestamp, // Use server timestamp for consistency
+        userId: session.userId,
+      })
+
+      // Update room's last modified timestamp
+      room.lastModified = serverTimestamp
+
+      // Broadcast to all other clients in the room (excluding sender)
+      const broadcastData = {
+        operation,
+        target,
+        payload,
+        timestamp: serverTimestamp,
+        senderId: socket.id,
+        userId: session.userId,
+        userName: session.userName,
+        // Add operation metadata for better client handling
+        metadata: {
+          workflowId,
+          operationId: crypto.randomUUID(), // Unique operation ID for tracking
+        },
+      }
+
+      socket.to(workflowId).emit('workflow-operation', broadcastData)
+
+      // Send confirmation back to sender with operation ID for tracking
+      socket.emit('operation-confirmed', {
+        operation,
+        target,
+        operationId: broadcastData.metadata.operationId,
+        serverTimestamp,
+      })
+
+      logger.info(
+        `✅ Operation ${operation} on ${target} in workflow ${workflowId} by user ${session.userId} (${session.userName})`
+      )
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        socket.emit('operation-error', {
+          type: 'VALIDATION_ERROR',
+          message: 'Invalid operation data',
+          errors: error.errors,
+          operation: data.operation,
+          target: data.target,
+        })
+        logger.warn(`Validation error for operation from ${session.userId}:`, error.errors)
+      } else if (error instanceof Error) {
+        // Handle specific database errors
+        if (error.message.includes('not found')) {
+          socket.emit('operation-error', {
+            type: 'RESOURCE_NOT_FOUND',
+            message: error.message,
+            operation: data.operation,
+            target: data.target,
+          })
+        } else if (error.message.includes('duplicate') || error.message.includes('unique')) {
+          socket.emit('operation-error', {
+            type: 'DUPLICATE_RESOURCE',
+            message: 'Resource already exists',
+            operation: data.operation,
+            target: data.target,
+          })
+        } else {
+          socket.emit('operation-error', {
+            type: 'OPERATION_FAILED',
+            message: error.message,
+            operation: data.operation,
+            target: data.target,
+          })
+        }
+        logger.error(
+          `Operation error for ${session.userId} (${data.operation} on ${data.target}):`,
+          error
+        )
+      } else {
+        socket.emit('operation-error', {
+          type: 'UNKNOWN_ERROR',
+          message: 'An unknown error occurred',
+          operation: data.operation,
+          target: data.target,
+        })
+        logger.error('Unknown error handling workflow operation:', error)
+      }
+    }
+  })
+
+  // Handle subblock value updates
+  socket.on('subblock-update', async (data) => {
+    const workflowId = socketToWorkflow.get(socket.id)
+    const session = userSessions.get(socket.id)
+
+    if (!workflowId || !session) {
+      logger.debug(`Ignoring subblock update: socket not connected to any workflow room`, {
+        socketId: socket.id,
+        hasWorkflowId: !!workflowId,
+        hasSession: !!session,
+      })
+      return
+    }
+
+    const { blockId, subblockId, value, timestamp } = data
+    const room = workflowRooms.get(workflowId)
+
+    if (!room) {
+      logger.debug(`Ignoring subblock update: workflow room not found`, {
+        socketId: socket.id,
+        workflowId,
+        blockId,
+        subblockId,
+      })
+      return
+    }
+
+    try {
+      // Update user activity
+      const userPresence = room.users.get(socket.id)
+      if (userPresence) {
+        userPresence.lastActivity = Date.now()
+      }
+
+      // First, verify that the workflow still exists in the database
+      const workflowExists = await db
+        .select({ id: workflow.id })
+        .from(workflow)
+        .where(eq(workflow.id, workflowId))
+        .limit(1)
+
+      if (workflowExists.length === 0) {
+        logger.warn(`Ignoring subblock update: workflow ${workflowId} no longer exists`, {
+          socketId: socket.id,
+          blockId,
+          subblockId,
+        })
+        // Clean up the socket from this non-existent workflow
+        cleanupUserFromRoom(socket.id, workflowId)
+        return
+      }
+
+      // Persist subblock update to database
+      let updateSuccessful = false
+      await db.transaction(async (tx) => {
+        // Get the current block subBlocks data
+        const [block] = await tx
+          .select({ subBlocks: workflowBlocks.subBlocks })
+          .from(workflowBlocks)
+          .where(and(eq(workflowBlocks.id, blockId), eq(workflowBlocks.workflowId, workflowId)))
+          .limit(1)
+
+        if (!block) {
+          // Block was deleted - this is a normal race condition in collaborative editing
+          // Log it as debug info and gracefully ignore the update
+          logger.debug(
+            `Ignoring subblock update for deleted block: ${workflowId}/${blockId}.${subblockId}`
+          )
+          return // Exit transaction gracefully without error
+        }
+
+        // Parse the current subBlocks data
+        const subBlocks = (block.subBlocks as any) || {}
+
+        // Update the subblock value in the subBlocks data
+        if (!subBlocks[subblockId]) {
+          subBlocks[subblockId] = {}
+        }
+        subBlocks[subblockId].value = value
+
+        // Save the updated subBlocks data back to the database
+        await tx
+          .update(workflowBlocks)
+          .set({
+            subBlocks: subBlocks,
+            updatedAt: new Date(),
+          })
+          .where(and(eq(workflowBlocks.id, blockId), eq(workflowBlocks.workflowId, workflowId)))
+
+        logger.debug(
+          `✅ Persisted subblock update: ${workflowId}/${blockId}.${subblockId} = ${JSON.stringify(value)}`
+        )
+        updateSuccessful = true
+      })
+
+      // Only broadcast to other clients if the update was successful
+      if (updateSuccessful) {
+        socket.to(workflowId).emit('subblock-update', {
+          blockId,
+          subblockId,
+          value,
+          timestamp,
+          senderId: socket.id,
+          userId: session.userId,
+        })
+      }
+
+      logger.debug(`Subblock update in workflow ${workflowId}: ${blockId}.${subblockId}`)
+    } catch (error) {
+      logger.error('Error handling subblock update:', error)
+
+      // Send error back to client
+      socket.emit('operation-error', {
+        type: 'SUBBLOCK_UPDATE_FAILED',
+        message: `Failed to update subblock ${blockId}.${subblockId}: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        operation: 'subblock-update',
+        target: 'subblock',
+      })
+    }
+  })
+
+  // Handle cursor/presence updates
+  socket.on('cursor-update', ({ cursor }) => {
+    const workflowId = socketToWorkflow.get(socket.id)
+    const session = userSessions.get(socket.id)
+
+    if (!workflowId || !session) return
+
+    const room = workflowRooms.get(workflowId)
+    if (!room) return
+
+    // Update stored cursor position
+    const userPresence = room.users.get(socket.id)
+    if (userPresence) {
+      userPresence.cursor = cursor
+      userPresence.lastActivity = Date.now()
+    }
+
+    // Broadcast cursor position to others in the room
+    socket.to(workflowId).emit('cursor-update', {
+      socketId: socket.id,
+      userId: session.userId,
+      userName: session.userName,
+      cursor,
+    })
+  })
+
+  // Handle user selection (for showing what block/element a user has selected)
+  socket.on('selection-update', ({ selection }) => {
+    const workflowId = socketToWorkflow.get(socket.id)
+    const session = userSessions.get(socket.id)
+
+    if (!workflowId || !session) return
+
+    const room = workflowRooms.get(workflowId)
+    if (!room) return
+
+    // Update stored selection
+    const userPresence = room.users.get(socket.id)
+    if (userPresence) {
+      userPresence.selection = selection
+      userPresence.lastActivity = Date.now()
+    }
+
+    socket.to(workflowId).emit('selection-update', {
+      socketId: socket.id,
+      userId: session.userId,
+      userName: session.userName,
+      selection, // { type: 'block' | 'edge' | 'none', id?: string }
+    })
+  })
+
+  // Handle disconnect with enhanced cleanup and recovery
+  socket.on('disconnect', (reason) => {
+    const workflowId = socketToWorkflow.get(socket.id)
+    const session = userSessions.get(socket.id)
+
+    logger.info(`Socket ${socket.id} disconnected: ${reason}`)
+
+    if (workflowId && session) {
+      // Clean up user from room
+      cleanupUserFromRoom(socket.id, workflowId)
+
+      // Notify others in the room
+      socket.to(workflowId).emit('user-left', {
+        userId: session.userId,
+        socketId: socket.id,
+        reason: reason,
+      })
+
+      logger.info(
+        `User ${session.userId} (${session.userName}) disconnected from workflow ${workflowId} - reason: ${reason}`
+      )
+    }
+
+    // Clear any pending operations for this socket
+    clearPendingOperations(socket.id)
+  })
+
+  // Handle connection errors
+  socket.on('error', (error) => {
+    logger.error(`Socket ${socket.id} error:`, error)
+    const session = userSessions.get(socket.id)
+    if (session) {
+      logger.error(`Error for user ${session.userId} (${session.userName}):`, error)
+    }
+  })
+
+  // Handle ping/pong for connection health
+  socket.on('ping', () => {
+    socket.emit('pong')
+  })
+
+  // Handle manual reconnection requests
+  socket.on('request-sync', async ({ workflowId }) => {
+    try {
+      if (!socket.userId) {
+        socket.emit('error', { type: 'NOT_AUTHENTICATED', message: 'Not authenticated' })
+        return
+      }
+
+      const accessInfo = await verifyWorkflowAccess(socket.userId, workflowId)
+      if (!accessInfo.hasAccess) {
+        socket.emit('error', { type: 'ACCESS_DENIED', message: 'Access denied' })
+        return
+      }
+
+      // Send current workflow state
+      const workflowState = await getWorkflowState(workflowId)
+      socket.emit('workflow-state', workflowState)
+
+      logger.info(`Sent sync data to ${socket.userId} for workflow ${workflowId}`)
+    } catch (error) {
+      logger.error('Error handling sync request:', error)
+      socket.emit('error', { type: 'SYNC_FAILED', message: 'Failed to sync workflow state' })
+    }
+  })
+
+  // Handle explicit leave workflow
+  socket.on('leave-workflow', () => {
+    const workflowId = socketToWorkflow.get(socket.id)
+    const session = userSessions.get(socket.id)
+
+    if (workflowId && session) {
+      socket.leave(workflowId)
+      cleanupUserFromRoom(socket.id, workflowId)
+
+      socket.to(workflowId).emit('user-left', {
+        userId: session.userId,
+        socketId: socket.id,
+      })
+
+      logger.info(`User ${session.userId} (${session.userName}) left workflow ${workflowId}`)
+    }
+  })
+})
+
+// Add detailed request logging
+httpServer.on('request', (req, res) => {
+  logger.info(`🌐 HTTP Request: ${req.method} ${req.url}`, {
+    method: req.method,
+    url: req.url,
+    userAgent: req.headers['user-agent'],
+    origin: req.headers.origin,
+    host: req.headers.host,
+    timestamp: new Date().toISOString(),
+  })
+})
+
+// Enhanced connection logging
+io.engine.on('connection_error', (err) => {
+  logger.error('❌ Engine.IO Connection error:', {
+    code: err.code,
+    message: err.message,
+    context: err.context,
+    req: err.req
+      ? {
+          url: err.req.url,
+          method: err.req.method,
+          headers: err.req.headers,
+        }
+      : 'No request object',
+  })
+})
+
+// Start the server
+const PORT = Number(process.env.PORT || process.env.SOCKET_PORT || 3002)
+
+logger.info('Starting Socket.IO server...', {
+  port: PORT,
+  nodeEnv: process.env.NODE_ENV,
+  hasDatabase: !!process.env.DATABASE_URL,
+  hasAuth: !!process.env.BETTER_AUTH_SECRET,
+})
+
+httpServer.listen(PORT, '0.0.0.0', () => {
+  logger.info(`✅ Socket.IO server running on port ${PORT}`)
+  logger.info(`🏥 Health check available at: http://localhost:${PORT}/health`)
+})
+
+httpServer.on('error', (error) => {
+  logger.error('❌ Server failed to start:', error)
+  process.exit(1)
+})
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+  logger.info('Shutting down Socket.IO server...')
+  httpServer.close(() => {
+    logger.info('Socket.IO server closed')
+    process.exit(0)
+  })
+})
+
+process.on('SIGTERM', () => {
+  logger.info('Shutting down Socket.IO server...')
+  httpServer.close(() => {
+    logger.info('Socket.IO server closed')
+    process.exit(0)
+  })
+})
diff --git a/apps/sim/stores/constants.ts b/apps/sim/stores/constants.ts
index ee7ac1a6942..c781c1f4b53 100644
--- a/apps/sim/stores/constants.ts
+++ b/apps/sim/stores/constants.ts
@@ -9,6 +9,4 @@ export const API_ENDPOINTS = {
   WORKSPACE_PERMISSIONS: (id: string) => `/api/workspaces/${id}/permissions`,
 }
 
-export const SYNC_INTERVALS = {
-  DEFAULT: 30000, // 30 seconds
-}
+// Removed SYNC_INTERVALS - Socket.IO handles real-time sync
diff --git a/apps/sim/stores/folders/store.ts b/apps/sim/stores/folders/store.ts
index 2287c8c60ea..efa25f2ef79 100644
--- a/apps/sim/stores/folders/store.ts
+++ b/apps/sim/stores/folders/store.ts
@@ -347,8 +347,8 @@ export const useFolderStore = create<FolderState>()(
         }
 
         if (workflowRegistry.activeWorkspaceId) {
-          const { fetchWorkflowsFromDB } = await import('../workflows/sync')
-          await fetchWorkflowsFromDB()
+          // Trigger workflow refresh through registry store
+          await workflowRegistry.switchToWorkspace(workflowRegistry.activeWorkspaceId)
         }
       },
 
diff --git a/apps/sim/stores/index.ts b/apps/sim/stores/index.ts
index 59d687bc3e9..347685dce12 100644
--- a/apps/sim/stores/index.ts
+++ b/apps/sim/stores/index.ts
@@ -9,9 +9,7 @@ import { useNotificationStore } from './notifications/store'
 import { useConsoleStore } from './panel/console/store'
 import { useVariablesStore } from './panel/variables/store'
 import { useEnvironmentStore } from './settings/environment/store'
-import { disposeSyncManagers, initializeSyncManagers } from './sync-registry'
-// Import the syncWorkflows function directly
-import { syncWorkflows } from './workflows'
+// Removed sync system imports - Socket.IO handles real-time sync
 import { useWorkflowRegistry } from './workflows/registry/store'
 import { useSubBlockStore } from './workflows/subblock/store'
 import { useWorkflowStore } from './workflows/workflow/store'
@@ -49,13 +47,8 @@ async function initializeApplication(): Promise<void> {
     // Load workspace based on workflow ID in URL, with fallback to last active workspace
     await useWorkflowRegistry.getState().loadWorkspaceFromWorkflowId(workflowIdFromUrl)
 
-    // Initialize sync system and wait for data to load completely
-    const syncInitialized = await initializeSyncManagers()
-
-    if (!syncInitialized) {
-      logger.error('Failed to initialize sync managers')
-      return
-    }
+    // Load workflows from database (replaced sync system)
+    await useWorkflowRegistry.getState().loadWorkflows()
 
     // Mark data as initialized only after sync managers have loaded data from DB
     dataInitialized = true
@@ -138,8 +131,7 @@ function handleBeforeUnload(event: BeforeUnloadEvent): void {
     }
   }
 
-  // Mark workflows as dirty to ensure sync on exit
-  syncWorkflows()
+  // Note: Socket.IO handles real-time sync automatically
 
   // Standard beforeunload pattern
   event.preventDefault()
@@ -151,7 +143,7 @@ function handleBeforeUnload(event: BeforeUnloadEvent): void {
  */
 function cleanupApplication(): void {
   window.removeEventListener('beforeunload', handleBeforeUnload)
-  disposeSyncManagers()
+  // Note: No sync managers to dispose - Socket.IO handles cleanup
 }
 
 /**
@@ -162,8 +154,7 @@ export async function clearUserData(): Promise<void> {
   if (typeof window === 'undefined') return
 
   try {
-    // Reset all sync managers to prevent any pending syncs
-    disposeSyncManagers()
+    // Note: No sync managers to dispose - Socket.IO handles cleanup
 
     // Reset all stores to their initial state
     resetAllStores()
@@ -219,8 +210,7 @@ export async function reinitializeAfterLogin(): Promise<void> {
     appFullyInitialized = false
     dataInitialized = false
 
-    // Reset sync managers to prevent any active syncs during reinitialization
-    disposeSyncManagers()
+    // Note: No sync managers to dispose - Socket.IO handles cleanup
 
     // Clean existing state to avoid stale data
     resetAllStores()
@@ -299,5 +289,4 @@ export const logAllStores = () => {
   return state
 }
 
-// Re-export sync managers
-export { workflowSync } from './workflows/sync'
+// Removed sync managers - Socket.IO handles real-time sync
diff --git a/apps/sim/stores/panel/variables/store.ts b/apps/sim/stores/panel/variables/store.ts
index 869d92bd946..68bb979128b 100644
--- a/apps/sim/stores/panel/variables/store.ts
+++ b/apps/sim/stores/panel/variables/store.ts
@@ -7,7 +7,7 @@ import { useSubBlockStore } from '@/stores/workflows/subblock/store'
 import type { Variable, VariablesStore } from './types'
 
 const logger = createLogger('VariablesStore')
-const SAVE_DEBOUNCE_DELAY = 500 // 500ms debounce delay
+const SAVE_DEBOUNCE_DELAY = 200 // Reduced debounce for variables (not real-time collaborative)
 
 // Map to store debounce timers for each workflow
 const saveTimers = new Map<string, NodeJS.Timeout>()
diff --git a/apps/sim/stores/sync-core.ts b/apps/sim/stores/sync-core.ts
deleted file mode 100644
index 4b2bd758812..00000000000
--- a/apps/sim/stores/sync-core.ts
+++ /dev/null
@@ -1,189 +0,0 @@
-import { createLogger } from '@/lib/logs/console-logger'
-
-const logger = createLogger('SyncCore')
-
-/**
- * Core sync types and utilities for optimistic state synchronization
- */
-
-// Configuration for a sync operation
-export interface SyncConfig {
-  // Required configuration
-  endpoint: string
-  preparePayload: () => Promise<any> | any
-  method?: 'GET' | 'POST' | 'DELETE' | 'PUT'
-
-  // Sync triggers
-  syncOnInterval?: boolean
-  syncOnExit?: boolean
-
-  // Optional configuration
-  syncInterval?: number
-  onSyncSuccess?: (response: any) => void
-  onSyncError?: (error: any) => void
-
-  // Enhanced retry configuration
-  maxRetries?: number
-  retryBackoff?: number
-}
-
-export const DEFAULT_SYNC_CONFIG: Partial<SyncConfig> = {
-  syncOnInterval: true,
-  syncOnExit: true,
-  syncInterval: 30000, // 30 seconds
-  maxRetries: 3,
-  retryBackoff: 1000, // Start with 1 second, will increase exponentially
-}
-
-// Core sync operations interface
-export interface SyncOperations {
-  sync: () => void
-  startIntervalSync: () => void
-  stopIntervalSync: () => void
-}
-
-// Sync state tracking to prevent concurrent sync operations
-const syncState = {
-  inProgress: new Map<string, boolean>(),
-  lastSyncTime: new Map<string, number>(),
-}
-
-// Returns true if a particular endpoint is currently syncing
-export function isSyncing(endpoint: string): boolean {
-  return syncState.inProgress.get(endpoint) === true
-}
-
-// Returns the timestamp of the last successful sync for an endpoint
-export function getLastSyncTime(endpoint: string): number | undefined {
-  return syncState.lastSyncTime.get(endpoint)
-}
-
-// Performs sync operation with automatic retry
-export async function performSync(config: SyncConfig): Promise<boolean> {
-  // Skip if sync already in progress for this endpoint
-  if (syncState.inProgress.get(config.endpoint)) {
-    logger.info(`Sync skipped - already in progress for ${config.endpoint}`)
-    return true
-  }
-
-  // Mark sync as in progress
-  syncState.inProgress.set(config.endpoint, true)
-
-  try {
-    // Get the payload to sync
-    const payload = await Promise.resolve(config.preparePayload())
-
-    // Skip sync if the payload indicates it should be skipped
-    if (payload && payload.skipSync === true) {
-      // Release lock and return success
-      syncState.inProgress.set(config.endpoint, false)
-      return true
-    }
-
-    // Normal API sync flow with retries
-    const result = await sendWithRetry(config.endpoint, payload, config)
-
-    // If successful, update last sync time
-    if (result) {
-      syncState.lastSyncTime.set(config.endpoint, Date.now())
-    }
-
-    return result
-  } catch (error) {
-    if (config.onSyncError) {
-      config.onSyncError(error)
-    }
-    logger.error(`Sync error for ${config.endpoint}: ${error}`)
-    return false
-  } finally {
-    // Always release the lock when done
-    syncState.inProgress.set(config.endpoint, false)
-  }
-}
-
-// Sends data to endpoint with configurable retries
-async function sendWithRetry(endpoint: string, payload: any, config: SyncConfig): Promise<boolean> {
-  const maxRetries = config.maxRetries || DEFAULT_SYNC_CONFIG.maxRetries || 3
-  const baseBackoff = config.retryBackoff || DEFAULT_SYNC_CONFIG.retryBackoff || 1000
-
-  let lastError: Error | null = null
-
-  for (let attempt = 0; attempt < maxRetries; attempt++) {
-    try {
-      const startTime = Date.now()
-      const result = await sendRequest(endpoint, payload, config)
-      const elapsed = Date.now() - startTime
-
-      if (result) {
-        // Only log retries if they happened
-        if (attempt > 0) {
-          logger.info(`Sync succeeded on attempt ${attempt + 1} for ${endpoint} after ${elapsed}ms`)
-        }
-        return true
-      }
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error))
-
-      // Calculate exponential backoff with jitter
-      const jitter = Math.random() * 0.3 + 0.85 // Random between 0.85 and 1.15
-      const backoff = baseBackoff * 2 ** attempt * jitter
-
-      logger.warn(
-        `Sync attempt ${attempt + 1}/${maxRetries} failed for ${endpoint}. Retrying in ${Math.round(backoff)}ms: ${lastError.message}`
-      )
-
-      // Only wait if we're going to retry
-      if (attempt < maxRetries - 1) {
-        await new Promise((resolve) => setTimeout(resolve, backoff))
-      }
-    }
-  }
-
-  // If we got here, all retries failed
-  if (lastError) {
-    if (config.onSyncError) {
-      config.onSyncError(lastError)
-    }
-    logger.error(`All ${maxRetries} sync attempts failed for ${endpoint}: ${lastError.message}`)
-  }
-
-  return false
-}
-
-// Sends a single request to the endpoint
-async function sendRequest(endpoint: string, payload: any, config: SyncConfig): Promise<boolean> {
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), 30000) // 30 second timeout
-
-  try {
-    const response = await fetch(endpoint, {
-      method: config.method || 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: config.method !== 'GET' ? JSON.stringify(payload) : undefined,
-      signal: controller.signal,
-      // Add cache control for GET requests to prevent caching
-      cache: config.method === 'GET' ? 'no-store' : undefined,
-    })
-
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => 'Failed to read error response')
-      throw new Error(`Sync failed: ${response.status} ${response.statusText} - ${errorText}`)
-    }
-
-    const data = await response.json()
-
-    if (config.onSyncSuccess) {
-      config.onSyncSuccess(data)
-    }
-
-    return true
-  } catch (error) {
-    // Handle abort (timeout) explicitly
-    if (error instanceof DOMException && error.name === 'AbortError') {
-      throw new Error('Sync request timed out after 30 seconds')
-    }
-    throw error
-  } finally {
-    clearTimeout(timeoutId)
-  }
-}
diff --git a/apps/sim/stores/sync-registry.ts b/apps/sim/stores/sync-registry.ts
deleted file mode 100644
index 9cd6bf37be4..00000000000
--- a/apps/sim/stores/sync-registry.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-'use client'
-
-import { createLogger } from '@/lib/logs/console-logger'
-import type { SyncManager } from './sync'
-import { fetchWorkflowsFromDB, workflowSync } from './workflows/sync'
-
-const logger = createLogger('SyncRegistry')
-
-// Initialize managers lazily
-let initialized = false
-let initializing = false
-let managers: SyncManager[] = []
-
-/**
- * Simplified sync managers initialization
- */
-export async function initializeSyncManagers(): Promise<boolean> {
-  // Skip if already initialized or initializing
-  if (initialized || initializing) {
-    return initialized
-  }
-
-  initializing = true
-
-  try {
-    // Initialize sync managers
-    managers = [workflowSync]
-
-    // Fetch data from DB and properly await completion
-    await fetchWorkflowsFromDB()
-    logger.info('Workflows loaded from database successfully')
-
-    initialized = true
-    return true
-  } catch (error) {
-    logger.error('Error initializing sync managers:', error)
-    // Still mark as initialized to allow the app to function with empty state
-    initialized = true
-    return true
-  } finally {
-    initializing = false
-  }
-}
-
-/**
- * Force resync all managers
- */
-export function forceSyncAll(): void {
-  if (!initialized) {
-    logger.warn('Sync managers not initialized, cannot force sync')
-    return
-  }
-
-  managers.forEach((manager) => {
-    try {
-      manager.sync()
-    } catch (error) {
-      logger.error('Error forcing sync for manager:', error)
-    }
-  })
-}
-
-/**
- * Dispose all sync managers
- */
-export function disposeSyncManagers(): void {
-  managers.forEach((manager) => {
-    try {
-      manager.dispose()
-    } catch (error) {
-      logger.error('Error disposing sync manager:', error)
-    }
-  })
-
-  managers = []
-  initialized = false
-  initializing = false
-}
diff --git a/apps/sim/stores/sync.ts b/apps/sim/stores/sync.ts
deleted file mode 100644
index 211b05c3433..00000000000
--- a/apps/sim/stores/sync.ts
+++ /dev/null
@@ -1,206 +0,0 @@
-'use client'
-
-import { useEffect } from 'react'
-import { createLogger } from '@/lib/logs/console-logger'
-import { SYNC_INTERVALS } from './constants'
-import { DEFAULT_SYNC_CONFIG, performSync, type SyncConfig, type SyncOperations } from './sync-core'
-
-const logger = createLogger('Sync')
-
-// Client-side sync manager with lifecycle and registry management
-export interface SyncManager extends SyncOperations {
-  id: string
-  config: SyncConfig
-  dispose: () => void // Cleanup function
-}
-
-// Registry of sync managers for system-wide operations
-const syncManagerRegistry = new Map<string, SyncManager>()
-
-// Creates a sync manager with optimistic updates
-export function createSyncManager(config: SyncConfig): SyncManager {
-  const id = `sync-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`
-
-  // Merge with defaults
-  const fullConfig: SyncConfig = {
-    ...DEFAULT_SYNC_CONFIG,
-    ...config,
-  }
-
-  // Optimistic sync - fire and forget
-  const sync = (): void => {
-    performSync(fullConfig).catch((err) => {
-      logger.error('Sync failed:', { err })
-    })
-  }
-
-  // Interval management
-  let intervalId: NodeJS.Timeout | null = null
-
-  const startIntervalSync = () => {
-    if (intervalId !== null || !fullConfig.syncInterval || !fullConfig.syncOnInterval) return
-
-    intervalId = setInterval(() => {
-      sync()
-    }, fullConfig.syncInterval)
-  }
-
-  const stopIntervalSync = () => {
-    if (intervalId !== null) {
-      clearInterval(intervalId)
-      intervalId = null
-    }
-  }
-
-  // Create the manager
-  const manager: SyncManager = {
-    id,
-    config: fullConfig,
-    sync,
-    startIntervalSync,
-    stopIntervalSync,
-    dispose: () => {
-      stopIntervalSync()
-      syncManagerRegistry.delete(id)
-    },
-  }
-
-  // Register in global registry
-  syncManagerRegistry.set(id, manager)
-
-  // Start interval if configured
-  if (fullConfig.syncOnInterval && fullConfig.syncInterval) {
-    startIntervalSync()
-  }
-
-  return manager
-}
-
-// Initializes the sync system with exit handlers
-export function initializeSyncSystem(): () => void {
-  if (typeof window === 'undefined') {
-    return () => {}
-  }
-
-  const handleBeforeUnload = (event: BeforeUnloadEvent) => {
-    // Check if we're on an authentication page and skip confirmation if we are
-    if (typeof window !== 'undefined') {
-      const path = window.location.pathname
-      // Skip confirmation for auth-related pages
-      if (
-        path === '/login' ||
-        path === '/signup' ||
-        path === '/reset-password' ||
-        path === '/verify'
-      ) {
-        return
-      }
-    }
-
-    // Find managers that need exit sync
-    const exitSyncManagers = Array.from(syncManagerRegistry.values()).filter(
-      (manager) => manager.config.syncOnExit
-    )
-
-    if (exitSyncManagers.length === 0) return
-
-    // Trigger all exit syncs
-    exitSyncManagers.forEach((manager) => {
-      manager.sync()
-    })
-
-    // Standard beforeunload pattern
-    event.preventDefault()
-    event.returnValue = ''
-  }
-
-  window.addEventListener('beforeunload', handleBeforeUnload)
-
-  return () => {
-    window.removeEventListener('beforeunload', handleBeforeUnload)
-  }
-}
-
-// React hook for using a sync manager in components
-export function useSyncManager(config: SyncConfig): SyncManager {
-  const manager = createSyncManager(config)
-
-  useEffect(() => {
-    return () => {
-      manager.dispose()
-    }
-  }, [manager])
-
-  return manager
-}
-
-// Creates a singleton sync manager for a specific store
-export function createSingletonSyncManager(
-  key: string,
-  configFactory: () => SyncConfig
-): SyncManager {
-  if (typeof window === 'undefined') {
-    // Return a no-op manager for server-side rendering
-    return {
-      id: key,
-      config: configFactory(),
-      sync: () => {},
-      startIntervalSync: () => {},
-      stopIntervalSync: () => {},
-      dispose: () => {},
-    }
-  }
-
-  const existing = syncManagerRegistry.get(key)
-  if (existing) {
-    return existing
-  }
-
-  const config = {
-    ...configFactory(),
-    syncInterval: SYNC_INTERVALS.DEFAULT,
-  }
-
-  const manager = {
-    id: key,
-    config,
-    sync: () => {
-      performSync(config).catch((err) => {
-        logger.error(`Sync failed for ${key}:`, { err })
-      })
-    },
-    startIntervalSync: () => {
-      if (!config.syncInterval || !config.syncOnInterval) return
-      manager.intervalId = setInterval(manager.sync, config.syncInterval)
-    },
-    stopIntervalSync: () => {
-      if (manager.intervalId) {
-        clearInterval(manager.intervalId)
-        manager.intervalId = null
-      }
-    },
-    dispose: () => {
-      manager.stopIntervalSync()
-      syncManagerRegistry.delete(key)
-    },
-    intervalId: null as NodeJS.Timeout | null,
-  }
-
-  syncManagerRegistry.set(key, manager)
-
-  if (config.syncOnInterval && config.syncInterval) {
-    manager.startIntervalSync()
-  }
-
-  return manager
-}
-
-// Creates a factory function for store-specific sync managers
-export function createSyncManagerFactory(baseConfig: Partial<SyncConfig>) {
-  return (config: Partial<SyncConfig>): SyncManager => {
-    return createSyncManager({
-      ...baseConfig,
-      ...config,
-    } as SyncConfig)
-  }
-}
diff --git a/apps/sim/stores/workflows/index.ts b/apps/sim/stores/workflows/index.ts
index ea9bdd8e141..161957de7c7 100644
--- a/apps/sim/stores/workflows/index.ts
+++ b/apps/sim/stores/workflows/index.ts
@@ -1,6 +1,5 @@
 import { createLogger } from '@/lib/logs/console-logger'
 import { useWorkflowRegistry } from './registry/store'
-import { workflowSync } from './sync'
 import { mergeSubblockState } from './utils'
 import { useWorkflowStore } from './workflow/store'
 import type { BlockState, WorkflowState } from './workflow/types'
@@ -158,13 +157,7 @@ export function getAllWorkflowsWithValues() {
   return result
 }
 
-/**
- * Convenience function to mark workflows as dirty and initiate a sync
- * This is a shortcut for other files to trigger sync operations
- */
-export function syncWorkflows() {
-  workflowSync.sync()
-}
+// Removed syncWorkflows - Socket.IO handles real-time sync automatically
 
 // Workflows store exports - localStorage persistence removed
 
@@ -173,7 +166,6 @@ export type { WorkflowMetadata } from './registry/types'
 export { useSubBlockStore } from './subblock/store'
 export type { SubBlockStore } from './subblock/types'
 // Re-export utilities
-export { workflowSync } from './sync'
 export { mergeSubblockState } from './utils'
 // Re-export store hooks
 export { useWorkflowStore } from './workflow/store'
diff --git a/apps/sim/stores/workflows/registry/store.ts b/apps/sim/stores/workflows/registry/store.ts
index deb4f46ad13..0ce08f959d5 100644
--- a/apps/sim/stores/workflows/registry/store.ts
+++ b/apps/sim/stores/workflows/registry/store.ts
@@ -4,7 +4,7 @@ import { createLogger } from '@/lib/logs/console-logger'
 import { clearWorkflowVariablesTracking } from '@/stores/panel/variables/store'
 import { API_ENDPOINTS } from '../../constants'
 import { useSubBlockStore } from '../subblock/store'
-import { fetchWorkflowsFromDB, workflowSync } from '../sync'
+// Removed fetchWorkflowsFromDB import - moved to local function
 import { useWorkflowStore } from '../workflow/store'
 import type { BlockState } from '../workflow/types'
 import type { DeploymentStatus, WorkflowMetadata, WorkflowRegistry } from './types'
@@ -12,6 +12,173 @@ import { generateUniqueName, getNextWorkflowColor } from './utils'
 
 const logger = createLogger('WorkflowRegistry')
 
+// Simplified function to fetch workflows from DB (moved from sync.ts)
+let isFetching = false
+let lastFetchTimestamp = 0
+
+async function fetchWorkflowsFromDB(): Promise<void> {
+  if (typeof window === 'undefined') return
+
+  // Prevent concurrent fetch operations
+  if (isFetching) {
+    logger.info('Fetch already in progress, skipping duplicate request')
+    return
+  }
+
+  const fetchStartTime = Date.now()
+  isFetching = true
+
+  try {
+    useWorkflowRegistry.getState().setLoading(true)
+
+    const activeWorkspaceId = useWorkflowRegistry.getState().activeWorkspaceId
+    const url = new URL(API_ENDPOINTS.SYNC, window.location.origin)
+
+    if (activeWorkspaceId) {
+      url.searchParams.append('workspaceId', activeWorkspaceId)
+    }
+
+    const response = await fetch(url.toString(), { method: 'GET' })
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        logger.warn('User not authenticated for workflow fetch')
+        useWorkflowRegistry.setState({ workflows: {}, isLoading: false })
+        return
+      }
+      throw new Error(`Failed to fetch workflows: ${response.statusText}`)
+    }
+
+    // Check if this fetch is still relevant (not superseded by a newer fetch)
+    if (fetchStartTime < lastFetchTimestamp) {
+      logger.info('Fetch superseded by newer operation, discarding results')
+      return
+    }
+
+    // Update timestamp to mark this as the most recent fetch
+    lastFetchTimestamp = fetchStartTime
+
+    const { data } = await response.json()
+
+    if (!data || !Array.isArray(data)) {
+      logger.info('No workflows found in database')
+
+      // Only clear workflows if we're confident this is a legitimate empty state
+      const currentWorkflows = useWorkflowRegistry.getState().workflows
+      const hasExistingWorkflows = Object.keys(currentWorkflows).length > 0
+
+      if (hasExistingWorkflows) {
+        logger.warn(
+          'Received empty workflow data but local workflows exist - possible race condition, preserving local state'
+        )
+        useWorkflowRegistry.setState({ isLoading: false })
+        return
+      }
+
+      useWorkflowRegistry.setState({ workflows: {}, isLoading: false })
+      return
+    }
+
+    // Process workflows
+    const registryWorkflows: Record<string, WorkflowMetadata> = {}
+    const deploymentStatuses: Record<string, any> = {}
+
+    data.forEach((workflow) => {
+      const {
+        id,
+        name,
+        description,
+        color,
+        state,
+        createdAt,
+        marketplaceData,
+        workspaceId,
+        folderId,
+        isDeployed,
+        deployedAt,
+        apiKey,
+      } = workflow
+
+      // Skip if workflow doesn't belong to active workspace
+      if (activeWorkspaceId && workspaceId !== activeWorkspaceId) {
+        return
+      }
+
+      // Add to registry
+      registryWorkflows[id] = {
+        id,
+        name,
+        description: description || '',
+        color: color || '#3972F6',
+        lastModified: createdAt ? new Date(createdAt) : new Date(),
+        marketplaceData: marketplaceData || null,
+        workspaceId,
+        folderId: folderId || null,
+      }
+
+      // Extract deployment status from database
+      if (isDeployed || deployedAt) {
+        deploymentStatuses[id] = {
+          isDeployed: isDeployed || false,
+          deployedAt: deployedAt ? new Date(deployedAt) : undefined,
+          apiKey: apiKey || undefined,
+          needsRedeployment: false,
+        }
+      }
+
+      // Initialize subblock values
+      const subblockValues: Record<string, Record<string, any>> = {}
+      if (state?.blocks) {
+        Object.entries(state.blocks).forEach(([blockId, block]) => {
+          const blockState = block as BlockState
+          subblockValues[blockId] = {}
+
+          Object.entries(blockState.subBlocks || {}).forEach(([subblockId, subblock]) => {
+            subblockValues[blockId][subblockId] = subblock.value
+          })
+        })
+      }
+
+      // Update subblock store
+      useSubBlockStore.setState((state) => ({
+        workflowValues: {
+          ...state.workflowValues,
+          [id]: subblockValues,
+        },
+      }))
+    })
+
+    // Update registry with loaded workflows and deployment statuses
+    useWorkflowRegistry.setState({
+      workflows: registryWorkflows,
+      deploymentStatuses: deploymentStatuses,
+      isLoading: false,
+      error: null,
+    })
+
+    // Only set first workflow as active if no active workflow is set and we have workflows
+    const currentState = useWorkflowRegistry.getState()
+    if (!currentState.activeWorkflowId && Object.keys(registryWorkflows).length > 0) {
+      const firstWorkflowId = Object.keys(registryWorkflows)[0]
+      useWorkflowRegistry.setState({ activeWorkflowId: firstWorkflowId })
+      logger.info(`Set first workflow as active: ${firstWorkflowId}`)
+    }
+
+    logger.info(
+      `Successfully loaded ${Object.keys(registryWorkflows).length} workflows from database`
+    )
+  } catch (error) {
+    logger.error('Error fetching workflows from DB:', error)
+    useWorkflowRegistry.setState({
+      isLoading: false,
+      error: `Failed to load workflows: ${error instanceof Error ? error.message : 'Unknown error'}`,
+    })
+    throw error
+  } finally {
+    isFetching = false
+  }
+}
+
 // Track workspace transitions to prevent race conditions
 let isWorkspaceTransitioning = false
 const TRANSITION_TIMEOUT = 5000 // 5 seconds maximum for workspace transitions
@@ -102,6 +269,11 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         set({ isLoading: loading })
       },
 
+      // Simple method to load workflows (replaces sync system)
+      loadWorkflows: async () => {
+        await fetchWorkflowsFromDB()
+      },
+
       // Handle cleanup on workspace deletion
       handleWorkspaceDeletion: async (newWorkspaceId: string) => {
         const currentWorkspaceId = get().activeWorkspaceId
@@ -392,8 +564,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
           }))
         }
 
-        // Trigger workflow sync to update server state
-        workflowSync.sync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       // Method to set the needsRedeployment flag for a specific workflow
@@ -442,8 +613,8 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         }
 
         // Fetch workflow state from database
-        const { fetchWorkflowStateFromDB } = await import('@/stores/workflows/sync')
-        const workflowData = await fetchWorkflowStateFromDB(id)
+        const response = await fetch(`/api/workflows/${id}`, { method: 'GET' })
+        const workflowData = response.ok ? (await response.json()).data : null
 
         let workflowState: any
 
@@ -491,100 +662,9 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
             },
           }))
         } else {
-          // If no state in DB, initialize with starter block (for newly created workflows)
-          const starterId = crypto.randomUUID()
-          const starterBlock = {
-            id: starterId,
-            type: 'starter' as const,
-            name: 'Start',
-            position: { x: 100, y: 100 },
-            subBlocks: {
-              startWorkflow: {
-                id: 'startWorkflow',
-                type: 'dropdown' as const,
-                value: 'manual',
-              },
-              webhookPath: {
-                id: 'webhookPath',
-                type: 'short-input' as const,
-                value: '',
-              },
-              webhookSecret: {
-                id: 'webhookSecret',
-                type: 'short-input' as const,
-                value: '',
-              },
-              scheduleType: {
-                id: 'scheduleType',
-                type: 'dropdown' as const,
-                value: 'daily',
-              },
-              minutesInterval: {
-                id: 'minutesInterval',
-                type: 'short-input' as const,
-                value: '',
-              },
-              minutesStartingAt: {
-                id: 'minutesStartingAt',
-                type: 'short-input' as const,
-                value: '',
-              },
-              hourlyMinute: {
-                id: 'hourlyMinute',
-                type: 'short-input' as const,
-                value: '',
-              },
-              dailyTime: {
-                id: 'dailyTime',
-                type: 'short-input' as const,
-                value: '',
-              },
-              weeklyDay: {
-                id: 'weeklyDay',
-                type: 'dropdown' as const,
-                value: 'MON',
-              },
-              weeklyDayTime: {
-                id: 'weeklyDayTime',
-                type: 'short-input' as const,
-                value: '',
-              },
-              monthlyDay: {
-                id: 'monthlyDay',
-                type: 'short-input' as const,
-                value: '',
-              },
-              monthlyTime: {
-                id: 'monthlyTime',
-                type: 'short-input' as const,
-                value: '',
-              },
-              cronExpression: {
-                id: 'cronExpression',
-                type: 'short-input' as const,
-                value: '',
-              },
-              timezone: {
-                id: 'timezone',
-                type: 'dropdown' as const,
-                value: 'UTC',
-              },
-            },
-            outputs: {
-              response: {
-                type: {
-                  input: 'any',
-                },
-              },
-            },
-            enabled: true,
-            horizontalHandles: true,
-            isWide: false,
-            height: 0,
-          }
-
+          // If no state in DB, use empty state - server should have created start block
           workflowState = {
-            blocks: { [starterId]: starterBlock },
+            blocks: {},
             edges: [],
             loops: {},
             parallels: {},
@@ -596,7 +676,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
               past: [],
               present: {
                 state: {
-                  blocks: { [starterId]: starterBlock },
+                  blocks: {},
                   edges: [],
                   loops: {},
                   parallels: {},
@@ -604,7 +684,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
                   deployedAt: undefined,
                 },
                 timestamp: Date.now(),
-                action: 'Initial state with starter block',
+                action: 'Empty initial state - server should provide start block',
                 subblockValues: {},
               },
               future: [],
@@ -612,19 +692,9 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
             lastSaved: Date.now(),
           }
 
-          // Initialize subblock values for starter block
-          const subblockValues: Record<string, Record<string, any>> = {}
-          subblockValues[starterId] = {}
-          Object.entries(starterBlock.subBlocks).forEach(([subblockId, subblock]) => {
-            subblockValues[starterId][subblockId] = (subblock as any).value
-          })
-
-          useSubBlockStore.setState((state) => ({
-            workflowValues: {
-              ...state.workflowValues,
-              [id]: subblockValues,
-            },
-          }))
+          logger.warn(
+            `Workflow ${id} has no state in DB - this should not happen with server-side start block creation`
+          )
         }
 
         // Set the workflow state in the store
@@ -648,6 +718,14 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         // Update the active workflow ID
         set({ activeWorkflowId: id, error: null })
 
+        // Emit a global event to notify that the active workflow has changed
+        // This allows the workflow component to join the socket room
+        window.dispatchEvent(
+          new CustomEvent('active-workflow-changed', {
+            detail: { workflowId: id },
+          })
+        )
+
         logger.info(`Switched to workflow ${id}`)
       },
 
@@ -656,7 +734,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
        * @param options - Optional configuration for workflow creation
        * @returns The ID of the newly created workflow
        */
-      createWorkflow: (options = {}) => {
+      createWorkflow: async (options = {}) => {
         const { workflows, activeWorkspaceId } = get()
         const id = crypto.randomUUID()
 
@@ -881,19 +959,82 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         set({ activeWorkflowId: id })
         useWorkflowStore.setState(initialState)
 
-        // Mark as dirty for sync and trigger immediate sync
-        useWorkflowStore.getState().sync.markDirty()
-        useWorkflowStore.getState().sync.forceSync()
+        // Immediately persist the new workflow to the database using dedicated endpoint
+        const persistWorkflow = async () => {
+          try {
+            const response = await fetch('/api/workflows', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                name: newWorkflow.name,
+                description: newWorkflow.description,
+                color: newWorkflow.color,
+                workspaceId: newWorkflow.workspaceId,
+                folderId: newWorkflow.folderId,
+              }),
+            })
 
-        logger.info(`Created new workflow with ID ${id} in workspace ${workspaceId || 'none'}`)
+            if (!response.ok) {
+              const errorData = await response.json()
+              throw new Error(
+                `Failed to create workflow: ${errorData.error || response.statusText}`
+              )
+            }
 
-        return id
+            const createdWorkflow = await response.json()
+            logger.info(`Successfully created workflow ${createdWorkflow.id} on server`)
+
+            // Update the local workflow ID to match the server-generated one
+            if (createdWorkflow.id !== id) {
+              logger.info(`Updating local workflow ID from ${id} to ${createdWorkflow.id}`)
+
+              // Update registry with server ID
+              set((state) => {
+                const { [id]: oldWorkflow, ...otherWorkflows } = state.workflows
+                return {
+                  workflows: {
+                    ...otherWorkflows,
+                    [createdWorkflow.id]: {
+                      ...oldWorkflow,
+                      id: createdWorkflow.id,
+                    },
+                  },
+                  activeWorkflowId: createdWorkflow.id,
+                }
+              })
+
+              // Return the server ID for the caller
+              return createdWorkflow.id
+            }
+
+            return id
+          } catch (error) {
+            logger.error(`Failed to create new workflow ${id}:`, error)
+            throw error // Re-throw to handle in calling code
+          }
+        }
+
+        // Persist synchronously to ensure workflow exists before Socket.IO operations
+        let finalId = id
+        try {
+          finalId = await persistWorkflow()
+        } catch (error) {
+          logger.error(
+            `Critical: Failed to persist new workflow ${id}, Socket.IO operations may fail:`,
+            error
+          )
+          // Don't throw - allow workflow creation to continue in memory
+        }
+
+        logger.info(`Created new workflow with ID ${finalId} in workspace ${workspaceId || 'none'}`)
+
+        return finalId
       },
 
       /**
        * Creates a new workflow from a marketplace workflow
        */
-      createMarketplaceWorkflow: (
+      createMarketplaceWorkflow: async (
         marketplaceId: string,
         state: any,
         metadata: Partial<WorkflowMetadata>
@@ -957,11 +1098,51 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         set({ activeWorkflowId: id })
         useWorkflowStore.setState(initialState)
 
-        // Mark as dirty to ensure sync
-        useWorkflowStore.getState().sync.markDirty()
+        // Immediately persist the marketplace workflow to the database
+        const persistWorkflow = async () => {
+          try {
+            const workflowData = {
+              [id]: {
+                id,
+                name: newWorkflow.name,
+                description: newWorkflow.description,
+                color: newWorkflow.color,
+                state: initialState,
+                marketplaceData: newWorkflow.marketplaceData,
+                workspaceId: newWorkflow.workspaceId,
+                folderId: newWorkflow.folderId,
+              },
+            }
 
-        // Trigger sync
-        useWorkflowStore.getState().sync.forceSync()
+            const response = await fetch('/api/workflows/sync', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                workflows: workflowData,
+                workspaceId: newWorkflow.workspaceId,
+              }),
+            })
+
+            if (!response.ok) {
+              throw new Error(`Failed to persist workflow: ${response.statusText}`)
+            }
+
+            logger.info(`Successfully persisted marketplace workflow ${id} to database`)
+          } catch (error) {
+            logger.error(`Failed to persist marketplace workflow ${id}:`, error)
+          }
+        }
+
+        // Persist synchronously to ensure workflow exists before Socket.IO operations
+        try {
+          await persistWorkflow()
+        } catch (error) {
+          logger.error(
+            `Critical: Failed to persist marketplace workflow ${id}, Socket.IO operations may fail:`,
+            error
+          )
+          // Don't throw - allow workflow creation to continue in memory
+        }
 
         logger.info(`Created marketplace workflow ${id} imported from ${marketplaceId}`)
 
@@ -971,7 +1152,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
       /**
        * Duplicates an existing workflow
        */
-      duplicateWorkflow: (sourceId: string) => {
+      duplicateWorkflow: async (sourceId: string) => {
         const { workflows, activeWorkspaceId } = get()
         const sourceWorkflow = workflows[sourceId]
 
@@ -980,12 +1161,44 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
           return null
         }
 
-        const id = crypto.randomUUID()
-
         // Get the workspace ID from the source workflow or fall back to active workspace
         const workspaceId = sourceWorkflow.workspaceId || activeWorkspaceId || undefined
 
-        // Generate new workflow metadata
+        // Call the server to duplicate the workflow - server generates all IDs
+        let duplicatedWorkflow
+        try {
+          const response = await fetch(`/api/workflows/${sourceId}/duplicate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              name: `${sourceWorkflow.name} (Copy)`,
+              description: sourceWorkflow.description,
+              color: sourceWorkflow.color,
+              workspaceId: workspaceId,
+              folderId: sourceWorkflow.folderId,
+            }),
+          })
+
+          if (!response.ok) {
+            throw new Error(`Failed to duplicate workflow: ${response.statusText}`)
+          }
+
+          duplicatedWorkflow = await response.json()
+          logger.info(
+            `Successfully duplicated workflow ${sourceId} to ${duplicatedWorkflow.id} with ${duplicatedWorkflow.blocksCount} blocks, ${duplicatedWorkflow.edgesCount} edges, ${duplicatedWorkflow.subflowsCount} subflows`
+          )
+        } catch (error) {
+          logger.error(`Failed to duplicate workflow ${sourceId}:`, error)
+          set({
+            error: `Failed to duplicate workflow: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          })
+          return null
+        }
+
+        // Use the server-generated ID
+        const id = duplicatedWorkflow.id
+
+        // Generate new workflow metadata using the server-generated ID
         const newWorkflow: WorkflowMetadata = {
           id,
           name: `${sourceWorkflow.name} (Copy)`,
@@ -993,6 +1206,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
           description: sourceWorkflow.description,
           color: getNextWorkflowColor(workflows),
           workspaceId, // Include the workspaceId in the new workflow
+          folderId: sourceWorkflow.folderId, // Include the folderId from source workflow
           // Do not copy marketplace data
         }
 
@@ -1185,9 +1399,7 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
         set({ activeWorkflowId: id })
         useWorkflowStore.setState(newState)
 
-        // Mark as dirty for sync and trigger immediate sync
-        useWorkflowStore.getState().sync.markDirty()
-        useWorkflowStore.getState().sync.forceSync()
+        // Workflow has already been persisted to the database via the duplication endpoint
 
         logger.info(
           `Duplicated workflow ${sourceId} to ${id} in workspace ${workspaceId || 'none'}`
@@ -1240,48 +1452,44 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
             return { workflowValues: newWorkflowValues }
           })
 
-          // If deleting active workflow, switch to another one or clear state
+          // If deleting active workflow, clear active workflow ID immediately
+          // Don't automatically switch to another workflow to prevent race conditions
           let newActiveWorkflowId = state.activeWorkflowId
           if (state.activeWorkflowId === id) {
-            const remainingIds = Object.keys(newWorkflows)
-            newActiveWorkflowId = remainingIds[0] || null
-
-            // Ensure the workflow we're switching to actually exists
-            if (newActiveWorkflowId && !newWorkflows[newActiveWorkflowId]) {
-              logger.warn(`Attempted to switch to non-existent workflow ${newActiveWorkflowId}`)
-              newActiveWorkflowId = null
-            }
-
-            if (!newActiveWorkflowId) {
-              // No workflows left, initialize empty state
-              useWorkflowStore.setState({
-                blocks: {},
-                edges: [],
-                loops: {},
-                parallels: {},
-                isDeployed: false,
-                deployedAt: undefined,
-                hasActiveSchedule: false,
-                history: {
-                  past: [],
-                  present: {
-                    state: {
-                      blocks: {},
-                      edges: [],
-                      loops: {},
-                      parallels: {},
-                      isDeployed: false,
-                      deployedAt: undefined,
-                    },
-                    timestamp: Date.now(),
-                    action: 'Initial state',
-                    subblockValues: {},
+            newActiveWorkflowId = null
+
+            // Clear workflow store state immediately when deleting active workflow
+            useWorkflowStore.setState({
+              blocks: {},
+              edges: [],
+              loops: {},
+              parallels: {},
+              isDeployed: false,
+              deployedAt: undefined,
+              hasActiveSchedule: false,
+              history: {
+                past: [],
+                present: {
+                  state: {
+                    blocks: {},
+                    edges: [],
+                    loops: {},
+                    parallels: {},
+                    isDeployed: false,
+                    deployedAt: undefined,
                   },
-                  future: [],
+                  timestamp: Date.now(),
+                  action: 'Workflow deleted',
+                  subblockValues: {},
                 },
-                lastSaved: Date.now(),
-              })
-            }
+                future: [],
+              },
+              lastSaved: Date.now(),
+            })
+
+            logger.info(
+              `Cleared active workflow ${id} - user will need to manually select another workflow`
+            )
           }
 
           // Cancel any schedule for this workflow (async, don't wait)
@@ -1312,31 +1520,69 @@ export const useWorkflowRegistry = create<WorkflowRegistry>()(
       },
 
       // Update workflow metadata
-      updateWorkflow: (id: string, metadata: Partial<WorkflowMetadata>) => {
-        set((state) => {
-          const workflow = state.workflows[id]
-          if (!workflow) return state
+      updateWorkflow: async (id: string, metadata: Partial<WorkflowMetadata>) => {
+        const { workflows } = get()
+        const workflow = workflows[id]
+        if (!workflow) {
+          logger.warn(`Cannot update workflow ${id}: not found in registry`)
+          return
+        }
 
-          const updatedWorkflows = {
+        // Optimistically update local state first
+        set((state) => ({
+          workflows: {
             ...state.workflows,
             [id]: {
               ...workflow,
               ...metadata,
               lastModified: new Date(),
             },
+          },
+          error: null,
+        }))
+
+        // Persist to database via API
+        try {
+          const response = await fetch(`/api/workflows/${id}`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(metadata),
+          })
+
+          if (!response.ok) {
+            const error = await response.json()
+            throw new Error(error.error || 'Failed to update workflow')
           }
 
-          // Mark as dirty to ensure sync
-          useWorkflowStore.getState().sync.markDirty()
+          const { workflow: updatedWorkflow } = await response.json()
+          logger.info(`Successfully updated workflow ${id} metadata`, metadata)
 
-          // Use PUT for workflow updates
-          useWorkflowStore.getState().sync.forceSync()
+          // Update with server response to ensure consistency
+          set((state) => ({
+            workflows: {
+              ...state.workflows,
+              [id]: {
+                ...state.workflows[id],
+                name: updatedWorkflow.name,
+                description: updatedWorkflow.description,
+                color: updatedWorkflow.color,
+                folderId: updatedWorkflow.folderId,
+                lastModified: new Date(updatedWorkflow.updatedAt),
+              },
+            },
+          }))
+        } catch (error) {
+          logger.error(`Failed to update workflow ${id} metadata:`, error)
 
-          return {
-            workflows: updatedWorkflows,
-            error: null,
-          }
-        })
+          // Revert optimistic update on error
+          set((state) => ({
+            workflows: {
+              ...state.workflows,
+              [id]: workflow, // Revert to original state
+            },
+            error: `Failed to update workflow: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          }))
+        }
       },
 
       logout: () => {
diff --git a/apps/sim/stores/workflows/registry/types.ts b/apps/sim/stores/workflows/registry/types.ts
index 797886778ae..efc854b835b 100644
--- a/apps/sim/stores/workflows/registry/types.ts
+++ b/apps/sim/stores/workflows/registry/types.ts
@@ -37,9 +37,10 @@ export interface WorkflowRegistryActions {
   setActiveWorkspaceId: (id: string) => void
   loadLastActiveWorkspace: () => Promise<void>
   loadWorkspaceFromWorkflowId: (workflowId: string | null) => Promise<void>
+  loadWorkflows: () => Promise<void>
   handleWorkspaceDeletion: (newWorkspaceId: string) => void
   removeWorkflow: (id: string) => Promise<void>
-  updateWorkflow: (id: string, metadata: Partial<WorkflowMetadata>) => void
+  updateWorkflow: (id: string, metadata: Partial<WorkflowMetadata>) => Promise<void>
   createWorkflow: (options?: {
     isInitial?: boolean
     marketplaceId?: string
@@ -48,13 +49,13 @@ export interface WorkflowRegistryActions {
     description?: string
     workspaceId?: string
     folderId?: string | null
-  }) => string
+  }) => Promise<string>
   createMarketplaceWorkflow: (
     marketplaceId: string,
     state: any,
     metadata: Partial<WorkflowMetadata>
-  ) => string
-  duplicateWorkflow: (sourceId: string) => string | null
+  ) => Promise<string>
+  duplicateWorkflow: (sourceId: string) => Promise<string | null>
   getWorkflowDeploymentStatus: (workflowId: string | null) => DeploymentStatus | null
   setDeploymentStatus: (
     workflowId: string | null,
diff --git a/apps/sim/stores/workflows/subblock/store.ts b/apps/sim/stores/workflows/subblock/store.ts
index bd1f64d25ca..47d8fdbf7b9 100644
--- a/apps/sim/stores/workflows/subblock/store.ts
+++ b/apps/sim/stores/workflows/subblock/store.ts
@@ -4,13 +4,11 @@ import type { SubBlockConfig } from '@/blocks/types'
 import { useEnvironmentStore } from '../../settings/environment/store'
 import { useGeneralStore } from '../../settings/general/store'
 import { useWorkflowRegistry } from '../registry/store'
-import { workflowSync } from '../sync'
+// Removed workflowSync import - Socket.IO handles real-time sync
 import type { SubBlockStore } from './types'
 import { extractEnvVarName, findMatchingEnvVar, isEnvVarReference } from './utils'
 
-// Add debounce utility for syncing
-let syncDebounceTimer: NodeJS.Timeout | null = null
-const DEBOUNCE_DELAY = 500 // 500ms delay for sync
+// Removed debounce sync - Socket.IO handles real-time sync immediately
 
 /**
  * SubBlockState stores values for all subblocks in workflows
@@ -70,8 +68,7 @@ export const useSubBlockStore = create<SubBlockStore>()(
         },
       }))
 
-      // Trigger sync to DB immediately on clear
-      workflowSync.sync()
+      // Note: Socket.IO handles real-time sync automatically
     },
 
     initializeFromWorkflow: (workflowId: string, blocks: Record<string, any>) => {
@@ -92,18 +89,9 @@ export const useSubBlockStore = create<SubBlockStore>()(
       }))
     },
 
-    // Debounced sync function to trigger DB sync
+    // Removed syncWithDB - Socket.IO handles real-time sync automatically
     syncWithDB: () => {
-      // Clear any existing timeout
-      if (syncDebounceTimer) {
-        clearTimeout(syncDebounceTimer)
-      }
-
-      // Set new timeout
-      syncDebounceTimer = setTimeout(() => {
-        // Trigger workflow sync to DB
-        workflowSync.sync()
-      }, DEBOUNCE_DELAY)
+      // No-op: Socket.IO handles real-time sync
     },
 
     // Tool params related functionality
diff --git a/apps/sim/stores/workflows/sync.ts b/apps/sim/stores/workflows/sync.ts
deleted file mode 100644
index dd85be310ed..00000000000
--- a/apps/sim/stores/workflows/sync.ts
+++ /dev/null
@@ -1,331 +0,0 @@
-'use client'
-
-import { createLogger } from '@/lib/logs/console-logger'
-import { API_ENDPOINTS } from '../constants'
-import { isDataInitialized } from '../index'
-import { createSingletonSyncManager } from '../sync'
-import { getAllWorkflowsWithValues } from '.'
-import { isWorkspaceInTransition, useWorkflowRegistry } from './registry/store'
-import type { WorkflowMetadata } from './registry/types'
-import { useSubBlockStore } from './subblock/store'
-import type { BlockState } from './workflow/types'
-
-const logger = createLogger('WorkflowsSync')
-
-// Simplified sync state tracking
-let lastSyncedData = ''
-let isSyncing = false
-let isFetching = false // Add lock to prevent concurrent fetches
-let lastFetchTimestamp = 0 // Track when we last fetched to prevent race conditions
-
-/**
- * Simplified workflow sync - no more complex flags and initialization checks
- */
-const workflowSyncConfig = {
-  endpoint: API_ENDPOINTS.SYNC,
-  preparePayload: () => {
-    if (typeof window === 'undefined') return { skipSync: true }
-
-    // Skip sync if data is not yet initialized from database
-    if (!isDataInitialized()) {
-      logger.info('Skipping sync: Data not yet initialized from database')
-      return { skipSync: true }
-    }
-
-    // Prevent concurrent syncs
-    if (isSyncing) {
-      return { skipSync: true }
-    }
-
-    // Block sync during workspace transitions to prevent race conditions
-    if (isWorkspaceInTransition()) {
-      logger.info('Skipping sync: Workspace transition in progress')
-      return { skipSync: true }
-    }
-
-    // Get all workflows with values
-    const allWorkflowsData = getAllWorkflowsWithValues()
-
-    // Skip sync if no workflows
-    if (Object.keys(allWorkflowsData).length === 0) {
-      return { skipSync: true }
-    }
-
-    // Safety check: Never sync if any workflow has empty state
-    // A valid workflow should always have at least a start block
-    const allWorkflowsHaveBlocks = Object.values(allWorkflowsData).every((workflow) => {
-      const blocks = workflow.state?.blocks || {}
-      return Object.keys(blocks).length > 0
-    })
-
-    if (!allWorkflowsHaveBlocks) {
-      logger.warn(
-        'Skipping sync: One or more workflows have empty state (no blocks). This indicates corrupted or incomplete workflow data.'
-      )
-      return { skipSync: true }
-    }
-
-    // Skip sync if no changes detected
-    const currentDataHash = JSON.stringify(allWorkflowsData)
-    if (currentDataHash === lastSyncedData) {
-      return { skipSync: true }
-    }
-
-    // Update last synced data hash
-    lastSyncedData = currentDataHash
-
-    // Get the active workspace ID
-    const activeWorkspaceId = useWorkflowRegistry.getState().activeWorkspaceId
-
-    // Ensure all workflows have required fields for validation
-    const workflowsData: Record<string, any> = {}
-    Object.entries(allWorkflowsData).forEach(([id, workflow]) => {
-      // Ensure state has required fields for Zod validation
-      const safeWorkflow = {
-        ...workflow,
-        state: {
-          blocks: workflow.state?.blocks || {},
-          edges: workflow.state?.edges || [],
-          loops: workflow.state?.loops || {},
-          parallels: workflow.state?.parallels || {},
-          ...workflow.state,
-        },
-      }
-
-      // Only include workspaceId if it exists
-      if (workflow.workspaceId || activeWorkspaceId) {
-        safeWorkflow.workspaceId = workflow.workspaceId || activeWorkspaceId
-      }
-
-      workflowsData[id] = safeWorkflow
-    })
-
-    isSyncing = true
-
-    const payload: any = {
-      workflows: workflowsData,
-    }
-
-    // Only include workspaceId if it exists (not null/undefined)
-    if (activeWorkspaceId) {
-      payload.workspaceId = activeWorkspaceId
-    }
-
-    return payload
-  },
-  method: 'POST' as const,
-  syncOnInterval: true,
-  syncOnExit: true,
-  onSyncSuccess: () => {
-    isSyncing = false
-    logger.info('Workflow sync completed successfully')
-  },
-  onSyncError: (error: any) => {
-    isSyncing = false
-    logger.error('Workflow sync failed:', error)
-  },
-}
-
-// Create the sync manager without debouncing or complex initialization checks
-export const workflowSync = createSingletonSyncManager('workflow-sync', () => workflowSyncConfig)
-
-/**
- * Simplified function to fetch workflows from DB
- */
-export async function fetchWorkflowsFromDB(): Promise<void> {
-  if (typeof window === 'undefined') return
-
-  // Prevent concurrent fetch operations
-  if (isFetching) {
-    logger.info('Fetch already in progress, skipping duplicate request')
-    return
-  }
-
-  const fetchStartTime = Date.now()
-  isFetching = true
-
-  try {
-    useWorkflowRegistry.getState().setLoading(true)
-
-    const activeWorkspaceId = useWorkflowRegistry.getState().activeWorkspaceId
-    const url = new URL(API_ENDPOINTS.SYNC, window.location.origin)
-
-    if (activeWorkspaceId) {
-      url.searchParams.append('workspaceId', activeWorkspaceId)
-    }
-
-    const response = await fetch(url.toString(), { method: 'GET' })
-
-    if (!response.ok) {
-      if (response.status === 401) {
-        logger.warn('User not authenticated for workflow fetch')
-        useWorkflowRegistry.setState({ workflows: {}, isLoading: false })
-        return
-      }
-      throw new Error(`Failed to fetch workflows: ${response.statusText}`)
-    }
-
-    // Check if this fetch is still relevant (not superseded by a newer fetch)
-    if (fetchStartTime < lastFetchTimestamp) {
-      logger.info('Fetch superseded by newer operation, discarding results')
-      return
-    }
-
-    // Update timestamp to mark this as the most recent fetch
-    lastFetchTimestamp = fetchStartTime
-
-    const { data } = await response.json()
-
-    if (!data || !Array.isArray(data)) {
-      logger.info('No workflows found in database')
-
-      // Only clear workflows if we're confident this is a legitimate empty state
-      // Avoid overwriting existing workflows during race conditions
-      const currentWorkflows = useWorkflowRegistry.getState().workflows
-      const hasExistingWorkflows = Object.keys(currentWorkflows).length > 0
-
-      if (hasExistingWorkflows) {
-        logger.warn(
-          'Received empty workflow data but local workflows exist - possible race condition, preserving local state'
-        )
-        useWorkflowRegistry.setState({ isLoading: false })
-        return
-      }
-
-      useWorkflowRegistry.setState({ workflows: {}, isLoading: false })
-      return
-    }
-
-    // Process workflows
-    const registryWorkflows: Record<string, WorkflowMetadata> = {}
-    const deploymentStatuses: Record<string, any> = {}
-
-    data.forEach((workflow) => {
-      const {
-        id,
-        name,
-        description,
-        color,
-        state,
-        createdAt,
-        marketplaceData,
-        workspaceId,
-        folderId,
-        isDeployed,
-        deployedAt,
-        apiKey,
-      } = workflow
-
-      // Skip if workflow doesn't belong to active workspace
-      if (activeWorkspaceId && workspaceId !== activeWorkspaceId) {
-        return
-      }
-
-      // Add to registry
-      registryWorkflows[id] = {
-        id,
-        name,
-        description: description || '',
-        color: color || '#3972F6',
-        lastModified: createdAt ? new Date(createdAt) : new Date(),
-        marketplaceData: marketplaceData || null,
-        workspaceId,
-        folderId: folderId || null,
-      }
-
-      // CRITICAL: Extract deployment status from database and add to registry
-      if (isDeployed || deployedAt) {
-        deploymentStatuses[id] = {
-          isDeployed: isDeployed || false,
-          deployedAt: deployedAt ? new Date(deployedAt) : undefined,
-          apiKey: apiKey || undefined,
-          needsRedeployment: false, // Default to false when loading from DB
-        }
-      }
-
-      // Initialize subblock values
-      const subblockValues: Record<string, Record<string, any>> = {}
-      if (state?.blocks) {
-        Object.entries(state.blocks).forEach(([blockId, block]) => {
-          const blockState = block as BlockState
-          subblockValues[blockId] = {}
-
-          Object.entries(blockState.subBlocks || {}).forEach(([subblockId, subblock]) => {
-            subblockValues[blockId][subblockId] = subblock.value
-          })
-        })
-      }
-
-      // Update subblock store
-      useSubBlockStore.setState((state) => ({
-        workflowValues: {
-          ...state.workflowValues,
-          [id]: subblockValues,
-        },
-      }))
-    })
-
-    // Update registry with loaded workflows and deployment statuses
-    useWorkflowRegistry.setState({
-      workflows: registryWorkflows,
-      deploymentStatuses: deploymentStatuses,
-      isLoading: false,
-      error: null,
-    })
-
-    // Only set first workflow as active if no active workflow is set and we have workflows
-    // This prevents race conditions from overriding an already-set active workflow
-    const currentState = useWorkflowRegistry.getState()
-    if (!currentState.activeWorkflowId && Object.keys(registryWorkflows).length > 0) {
-      const firstWorkflowId = Object.keys(registryWorkflows)[0]
-      useWorkflowRegistry.setState({ activeWorkflowId: firstWorkflowId })
-      logger.info(`Set first workflow as active: ${firstWorkflowId}`)
-    }
-
-    logger.info(
-      `Successfully loaded ${Object.keys(registryWorkflows).length} workflows from database`
-    )
-  } catch (error) {
-    logger.error('Error fetching workflows from DB:', error)
-    useWorkflowRegistry.setState({
-      isLoading: false,
-      error: `Failed to load workflows: ${error instanceof Error ? error.message : 'Unknown error'}`,
-    })
-    // Re-throw to allow caller to handle the error appropriately
-    throw error
-  } finally {
-    isFetching = false
-  }
-}
-
-/**
- * Fetch a single workflow state from the database
- */
-export async function fetchWorkflowStateFromDB(workflowId: string): Promise<any | null> {
-  try {
-    const response = await fetch(`/api/workflows/${workflowId}`, { method: 'GET' })
-
-    if (!response.ok) {
-      if (response.status === 404) {
-        logger.warn(`Workflow ${workflowId} not found in database`)
-        return null
-      }
-      throw new Error(`Failed to fetch workflow: ${response.statusText}`)
-    }
-
-    const { data } = await response.json()
-    return data
-  } catch (error) {
-    logger.error(`Error fetching workflow ${workflowId} from DB:`, error)
-    return null
-  }
-}
-
-/**
- * Mark workflows as dirty for sync
- */
-export function markWorkflowsDirty(): void {
-  // Force a sync by clearing the last synced data hash
-  lastSyncedData = ''
-  logger.info('Workflows marked as dirty')
-}
diff --git a/apps/sim/stores/workflows/workflow/store.test.ts b/apps/sim/stores/workflows/workflow/store.test.ts
index 1a8ed09aa4c..a1bcbe146be 100644
--- a/apps/sim/stores/workflows/workflow/store.test.ts
+++ b/apps/sim/stores/workflows/workflow/store.test.ts
@@ -224,8 +224,37 @@ describe('workflow store', () => {
       expect(state.blocks.parallel1?.data?.count).toBe(1)
     })
 
+    it('should regenerate parallels when updateParallelType is called', () => {
+      const { addBlock, updateParallelType } = useWorkflowStore.getState()
+
+      // Add a parallel block with default collection type
+      addBlock(
+        'parallel1',
+        'parallel',
+        'Test Parallel',
+        { x: 0, y: 0 },
+        {
+          parallelType: 'collection',
+          count: 3,
+          collection: '["a", "b", "c"]',
+        }
+      )
+
+      // Update parallel type to count
+      updateParallelType('parallel1', 'count')
+
+      const state = useWorkflowStore.getState()
+
+      // Check that block data was updated
+      expect(state.blocks.parallel1?.data?.parallelType).toBe('count')
+
+      // Check that parallels were regenerated with new type
+      expect(state.parallels.parallel1).toBeDefined()
+      expect(state.parallels.parallel1.parallelType).toBe('count')
+    })
+
     it('should save to history when updating parallel properties', () => {
-      const { addBlock, updateParallelCollection, updateParallelCount } =
+      const { addBlock, updateParallelCollection, updateParallelCount, updateParallelType } =
         useWorkflowStore.getState()
 
       // Add a parallel block
@@ -254,6 +283,12 @@ describe('workflow store', () => {
 
       state = useWorkflowStore.getState()
       expect(state.history.past.length).toBe(initialHistoryLength + 2)
+
+      // Update parallel type
+      updateParallelType('parallel1', 'count')
+
+      state = useWorkflowStore.getState()
+      expect(state.history.past.length).toBe(initialHistoryLength + 3)
     })
   })
 
diff --git a/apps/sim/stores/workflows/workflow/store.ts b/apps/sim/stores/workflows/workflow/store.ts
index 8b417fbfdf9..9a7ff740648 100644
--- a/apps/sim/stores/workflows/workflow/store.ts
+++ b/apps/sim/stores/workflows/workflow/store.ts
@@ -3,11 +3,10 @@ import { create } from 'zustand'
 import { devtools } from 'zustand/middleware'
 import { getBlock } from '@/blocks'
 import { resolveOutputType } from '@/blocks/utils'
-import { isDataInitialized } from '../../index'
 import { pushHistory, type WorkflowStoreWithHistory, withHistory } from '../middleware'
 import { useWorkflowRegistry } from '../registry/store'
 import { useSubBlockStore } from '../subblock/store'
-import { markWorkflowsDirty, workflowSync } from '../sync'
+// import { markWorkflowsDirty, workflowSync } from '../sync' // Disabled for socket-based sync
 import { mergeSubblockState } from '../utils'
 import type { Position, SubBlockState, SyncControl, WorkflowState } from './types'
 import { generateLoopBlocks, generateParallelBlocks } from './utils'
@@ -47,32 +46,18 @@ const initialState = {
 
 // Create a consolidated sync control implementation
 /**
- * Simplified SyncControl implementation
+ * Socket-based SyncControl implementation (replaces HTTP sync)
  */
 const createSyncControl = (): SyncControl => ({
   markDirty: () => {
-    // Only mark dirty if data is initialized
-    if (!isDataInitialized()) {
-      return
-    }
-    // Simply mark workflows as dirty for sync
-    markWorkflowsDirty()
+    // No-op: Socket-based sync handles this automatically
   },
   isDirty: () => {
-    // Always return true - let the sync system decide if sync is needed
-    return true
+    // Always return false since socket sync is real-time
+    return false
   },
   forceSync: () => {
-    // Only force sync if data is initialized
-    if (!isDataInitialized()) {
-      return
-    }
-    // Force sync by marking dirty and syncing
-    markWorkflowsDirty()
-    // Small delay to ensure state has settled
-    setTimeout(() => {
-      workflowSync.sync()
-    }, 100)
+    // No-op: Socket-based sync is always in sync
   },
 })
 
@@ -136,7 +121,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
           set(newState)
           pushHistory(set, get, newState, `Add ${type} node`)
           get().updateLastSaved()
-          get().sync.markDirty()
+          // get().sync.markDirty() // Disabled: Using socket-based sync
           return
         }
 
@@ -185,7 +170,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, `Add ${type} block`)
         get().updateLastSaved()
-        get().sync.markDirty()
+        // get().sync.markDirty() // Disabled: Using socket-based sync
       },
 
       updateBlockPosition: (id: string, position: Position) => {
@@ -219,7 +204,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
           edges: [...state.edges],
         }))
         get().updateLastSaved()
-        get().sync.markDirty()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       updateParentId: (id: string, parentId: string, extent: 'parent') => {
@@ -290,8 +275,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
           parentId ? `Set parent for ${block.name}` : `Remove parent for ${block.name}`
         )
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       removeBlock: (id: string) => {
@@ -362,7 +346,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, 'Remove block and children')
         get().updateLastSaved()
-        get().sync.markDirty()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       addEdge: (edge: Edge) => {
@@ -400,7 +384,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, 'Add connection')
         get().updateLastSaved()
-        get().sync.markDirty()
+        // get().sync.markDirty() // Disabled: Using socket-based sync
       },
 
       removeEdge: (edgeId: string) => {
@@ -423,7 +407,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, 'Remove connection')
         get().updateLastSaved()
-        get().sync.markDirty()
+        // get().sync.markDirty() // Disabled: Using socket-based sync
       },
 
       clear: () => {
@@ -456,13 +440,13 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
           hasActiveWebhook: false,
         }
         set(newState)
-        get().sync.markDirty()
+        // Note: Socket.IO handles real-time sync automatically
         return newState
       },
 
       updateLastSaved: () => {
         set({ lastSaved: Date.now() })
-        // Note: Scheduling changes are automatically handled by the workflowSync
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       toggleBlockEnabled: (id: string) => {
@@ -481,7 +465,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
 
         set(newState)
         get().updateLastSaved()
-        get().sync.markDirty()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       duplicateBlock: (id: string) => {
@@ -550,8 +534,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, `Duplicate ${block.type} block`)
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       toggleBlockHandles: (id: string) => {
@@ -569,8 +552,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
 
         set(newState)
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       updateBlockName: (id: string, name: string) => {
@@ -656,8 +638,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, `${name} block name updated`)
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       toggleBlockWide: (id: string) => {
@@ -673,8 +654,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
           loops: { ...state.loops },
         }))
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       updateBlockHeight: (id: string, height: number) => {
@@ -779,7 +759,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         if (get().hasActiveSchedule !== hasActiveSchedule) {
           set({ hasActiveSchedule })
           get().updateLastSaved()
-          get().sync.markDirty()
+          // Note: Socket.IO handles real-time sync automatically
         }
       },
 
@@ -793,7 +773,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
 
           set({ hasActiveWebhook })
           get().updateLastSaved()
-          get().sync.markDirty()
+          // Note: Socket.IO handles real-time sync automatically
         }
       },
 
@@ -860,8 +840,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
 
         pushHistory(set, get, newState, 'Reverted to deployed state')
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       toggleBlockAdvancedMode: (id: string) => {
@@ -912,8 +891,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         }
 
         get().triggerUpdate()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       // Parallel block methods implementation
@@ -942,8 +920,7 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, `Update parallel count`)
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       updateParallelCollection: (parallelId: string, collection: string) => {
@@ -971,8 +948,35 @@ export const useWorkflowStore = create<WorkflowStoreWithHistory>()(
         set(newState)
         pushHistory(set, get, newState, `Update parallel collection`)
         get().updateLastSaved()
-        get().sync.markDirty()
-        get().sync.forceSync()
+        // Note: Socket.IO handles real-time sync automatically
+      },
+
+      updateParallelType: (parallelId: string, parallelType: 'count' | 'collection') => {
+        const block = get().blocks[parallelId]
+        if (!block || block.type !== 'parallel') return
+
+        const newBlocks = {
+          ...get().blocks,
+          [parallelId]: {
+            ...block,
+            data: {
+              ...block.data,
+              parallelType,
+            },
+          },
+        }
+
+        const newState = {
+          blocks: newBlocks,
+          edges: [...get().edges],
+          loops: { ...get().loops },
+          parallels: generateParallelBlocks(newBlocks), // Regenerate parallels
+        }
+
+        set(newState)
+        pushHistory(set, get, newState, `Update parallel type`)
+        get().updateLastSaved()
+        // Note: Socket.IO handles real-time sync automatically
       },
 
       // Function to convert UI parallel blocks to execution format
diff --git a/apps/sim/stores/workflows/workflow/types.ts b/apps/sim/stores/workflows/workflow/types.ts
index c59b1b16a01..2baf5a1fa07 100644
--- a/apps/sim/stores/workflows/workflow/types.ts
+++ b/apps/sim/stores/workflows/workflow/types.ts
@@ -130,6 +130,8 @@ export interface Parallel {
   id: string
   nodes: string[]
   distribution?: any[] | Record<string, any> | string // Items or expression
+  count?: number // Number of parallel executions for count-based parallel
+  parallelType?: 'count' | 'collection' // Explicit parallel type to avoid inference bugs
 }
 
 export interface WorkflowState {
@@ -189,6 +191,7 @@ export interface WorkflowActions {
   updateLoopCollection: (loopId: string, collection: string) => void
   updateParallelCount: (parallelId: string, count: number) => void
   updateParallelCollection: (parallelId: string, collection: string) => void
+  updateParallelType: (parallelId: string, parallelType: 'count' | 'collection') => void
   generateLoopBlocks: () => Record<string, Loop>
   generateParallelBlocks: () => Record<string, Parallel>
   setNeedsRedeploymentFlag: (needsRedeployment: boolean) => void
diff --git a/apps/sim/stores/workflows/workflow/utils.ts b/apps/sim/stores/workflows/workflow/utils.ts
index 3af55ed435d..8b9e8d4a374 100644
--- a/apps/sim/stores/workflows/workflow/utils.ts
+++ b/apps/sim/stores/workflows/workflow/utils.ts
@@ -53,7 +53,7 @@ export function convertParallelBlockToParallel(
   const parallelBlock = blocks[parallelBlockId]
   if (!parallelBlock || parallelBlock.type !== 'parallel') return undefined
 
-  // Only set distribution if it's a collection-based parallel
+  // Get the parallel type from block data, defaulting to 'collection' for backward compatibility
   const parallelType = parallelBlock.data?.parallelType || 'collection'
 
   // Validate parallelType against allowed values
@@ -62,13 +62,18 @@ export function convertParallelBlockToParallel(
     ? parallelType
     : 'collection'
 
+  // Only set distribution if it's a collection-based parallel
   const distribution =
     validatedParallelType === 'collection' ? parallelBlock.data?.collection || '' : ''
 
+  const count = parallelBlock.data?.count || 5
+
   return {
     id: parallelBlockId,
     nodes: findChildNodes(parallelBlockId, blocks),
     distribution,
+    count,
+    parallelType: validatedParallelType,
   }
 }
 
diff --git a/apps/sim/test-socket-integration.html b/apps/sim/test-socket-integration.html
new file mode 100644
index 00000000000..61af75221a5
--- /dev/null
+++ b/apps/sim/test-socket-integration.html
@@ -0,0 +1,275 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Socket Integration Test</title>
+    <script src="https://cdn.socket.io/4.8.1/socket.io.min.js"></script>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; }
+        .container { max-width: 800px; margin: 0 auto; }
+        .status { padding: 10px; margin: 10px 0; border-radius: 5px; }
+        .connected { background-color: #d4edda; color: #155724; }
+        .disconnected { background-color: #f8d7da; color: #721c24; }
+        .log { background-color: #f8f9fa; padding: 10px; margin: 10px 0; border-radius: 5px; max-height: 300px; overflow-y: auto; }
+        button { padding: 10px 20px; margin: 5px; background-color: #007bff; color: white; border: none; border-radius: 5px; cursor: pointer; }
+        button:hover { background-color: #0056b3; }
+        button:disabled { background-color: #6c757d; cursor: not-allowed; }
+        input { padding: 8px; margin: 5px; border: 1px solid #ccc; border-radius: 3px; }
+        .presence { background-color: #e7f3ff; padding: 10px; margin: 10px 0; border-radius: 5px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Socket.IO Collaborative Workflow Test</h1>
+        
+        <div id="status" class="status disconnected">
+            Disconnected
+        </div>
+        
+        <div class="presence">
+            <h3>Presence Users:</h3>
+            <div id="presence-users">None</div>
+        </div>
+        
+        <div>
+            <h3>Test Workflow Operations:</h3>
+            <input type="text" id="workflow-id" placeholder="Workflow ID" value="test-workflow-123">
+            <button onclick="joinWorkflow()">Join Workflow</button>
+            <button onclick="leaveWorkflow()">Leave Workflow</button>
+        </div>
+        
+        <div>
+            <h3>Block Operations:</h3>
+            <button onclick="addTestBlock()">Add Test Block</button>
+            <button onclick="removeTestBlock()">Remove Test Block</button>
+            <button onclick="updateBlockPosition()">Update Block Position</button>
+        </div>
+        
+        <div>
+            <h3>Edge Operations:</h3>
+            <button onclick="addTestEdge()">Add Test Edge</button>
+            <button onclick="removeTestEdge()">Remove Test Edge</button>
+        </div>
+        
+        <div class="log">
+            <h3>Event Log:</h3>
+            <div id="log"></div>
+        </div>
+    </div>
+
+    <script>
+        let socket = null;
+        let currentWorkflowId = null;
+        let testBlockId = 'test-block-' + Math.random().toString(36).substr(2, 9);
+        let testEdgeId = 'test-edge-' + Math.random().toString(36).substr(2, 9);
+
+        function log(message) {
+            const logDiv = document.getElementById('log');
+            const timestamp = new Date().toLocaleTimeString();
+            logDiv.innerHTML += `<div>[${timestamp}] ${message}</div>`;
+            logDiv.scrollTop = logDiv.scrollHeight;
+        }
+
+        function updateStatus(connected) {
+            const statusDiv = document.getElementById('status');
+            if (connected) {
+                statusDiv.className = 'status connected';
+                statusDiv.textContent = 'Connected to Socket.IO server';
+            } else {
+                statusDiv.className = 'status disconnected';
+                statusDiv.textContent = 'Disconnected from Socket.IO server';
+            }
+        }
+
+        function updatePresence(users) {
+            const presenceDiv = document.getElementById('presence-users');
+            if (users.length === 0) {
+                presenceDiv.textContent = 'None';
+            } else {
+                presenceDiv.innerHTML = users.map(user => 
+                    `<div>• ${user.userName} (${user.userId})</div>`
+                ).join('');
+            }
+        }
+
+        // Initialize socket connection
+        function initSocket() {
+            socket = io('http://localhost:3002', {
+                withCredentials: false, // Disable for testing
+                transports: ['polling', 'websocket'],
+                forceNew: true,
+                timeout: 5000
+            });
+
+            socket.on('connect', () => {
+                log('✅ Connected to socket server');
+                updateStatus(true);
+            });
+
+            socket.on('disconnect', (reason) => {
+                log(`❌ Disconnected: ${reason}`);
+                updateStatus(false);
+                updatePresence([]);
+            });
+
+            socket.on('error', (error) => {
+                log(`🚨 Socket error: ${JSON.stringify(error)}`);
+            });
+
+            socket.on('workflow-operation', (data) => {
+                log(`📝 Received operation: ${data.operation} on ${data.target} from ${data.userName || data.userId}`);
+                log(`   Payload: ${JSON.stringify(data.payload)}`);
+            });
+
+            socket.on('user-joined', (data) => {
+                log(`👋 User joined: ${data.userName || data.userId}`);
+            });
+
+            socket.on('user-left', (data) => {
+                log(`👋 User left: ${data.userId}`);
+            });
+
+            socket.on('presence-update', (users) => {
+                log(`👥 Presence update: ${users.length} users`);
+                updatePresence(users);
+            });
+
+            socket.on('operation-confirmed', (data) => {
+                log(`✅ Operation confirmed: ${data.operation} on ${data.target}`);
+            });
+
+            socket.on('operation-error', (error) => {
+                log(`❌ Operation error: ${error.message || error.error}`);
+            });
+
+            socket.on('operation-forbidden', (error) => {
+                log(`🚫 Operation forbidden: ${error.message}`);
+            });
+        }
+
+        function joinWorkflow() {
+            const workflowId = document.getElementById('workflow-id').value;
+            if (!workflowId || !socket) return;
+
+            currentWorkflowId = workflowId;
+            socket.emit('join-workflow', { workflowId });
+            log(`🔗 Joining workflow: ${workflowId}`);
+        }
+
+        function leaveWorkflow() {
+            if (!socket) return;
+            socket.emit('leave-workflow');
+            currentWorkflowId = null;
+            log('🔗 Left workflow');
+            updatePresence([]);
+        }
+
+        function addTestBlock() {
+            if (!socket || !currentWorkflowId) {
+                log('❌ Not connected to a workflow');
+                return;
+            }
+
+            const operation = {
+                operation: 'add',
+                target: 'block',
+                payload: {
+                    id: testBlockId,
+                    type: 'action',
+                    name: 'Test Block',
+                    position: { x: Math.random() * 400, y: Math.random() * 300 },
+                    data: {}
+                },
+                timestamp: Date.now()
+            };
+
+            socket.emit('workflow-operation', operation);
+            log(`📤 Sent add block operation: ${testBlockId}`);
+        }
+
+        function removeTestBlock() {
+            if (!socket || !currentWorkflowId) {
+                log('❌ Not connected to a workflow');
+                return;
+            }
+
+            const operation = {
+                operation: 'remove',
+                target: 'block',
+                payload: { id: testBlockId },
+                timestamp: Date.now()
+            };
+
+            socket.emit('workflow-operation', operation);
+            log(`📤 Sent remove block operation: ${testBlockId}`);
+        }
+
+        function updateBlockPosition() {
+            if (!socket || !currentWorkflowId) {
+                log('❌ Not connected to a workflow');
+                return;
+            }
+
+            const operation = {
+                operation: 'update-position',
+                target: 'block',
+                payload: {
+                    id: testBlockId,
+                    position: { x: Math.random() * 400, y: Math.random() * 300 }
+                },
+                timestamp: Date.now()
+            };
+
+            socket.emit('workflow-operation', operation);
+            log(`📤 Sent update position operation: ${testBlockId}`);
+        }
+
+        function addTestEdge() {
+            if (!socket || !currentWorkflowId) {
+                log('❌ Not connected to a workflow');
+                return;
+            }
+
+            const operation = {
+                operation: 'add',
+                target: 'edge',
+                payload: {
+                    id: testEdgeId,
+                    source: 'source-block-id',
+                    target: 'target-block-id',
+                    sourceHandle: 'source',
+                    targetHandle: 'target'
+                },
+                timestamp: Date.now()
+            };
+
+            socket.emit('workflow-operation', operation);
+            log(`📤 Sent add edge operation: ${testEdgeId}`);
+        }
+
+        function removeTestEdge() {
+            if (!socket || !currentWorkflowId) {
+                log('❌ Not connected to a workflow');
+                return;
+            }
+
+            const operation = {
+                operation: 'remove',
+                target: 'edge',
+                payload: { id: testEdgeId },
+                timestamp: Date.now()
+            };
+
+            socket.emit('workflow-operation', operation);
+            log(`📤 Sent remove edge operation: ${testEdgeId}`);
+        }
+
+        // Initialize on page load
+        window.onload = () => {
+            log('🚀 Initializing socket connection...');
+            initSocket();
+        };
+    </script>
+</body>
+</html>
diff --git a/apps/sim/tests/socket-server.test.ts b/apps/sim/tests/socket-server.test.ts
new file mode 100644
index 00000000000..2414716791c
--- /dev/null
+++ b/apps/sim/tests/socket-server.test.ts
@@ -0,0 +1,227 @@
+import { createServer } from 'http'
+import { Server } from 'socket.io'
+import { io, type Socket } from 'socket.io-client'
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest'
+
+describe('Socket Server Integration Tests', () => {
+  let httpServer: any
+  let socketServer: Server
+  let clientSocket: Socket
+  let serverPort: number
+
+  beforeAll(async () => {
+    // Create a test server instance
+    httpServer = createServer()
+    socketServer = new Server(httpServer, {
+      cors: {
+        origin: '*',
+        methods: ['GET', 'POST'],
+      },
+    })
+
+    // Start server on random port
+    await new Promise<void>((resolve) => {
+      httpServer.listen(() => {
+        serverPort = httpServer.address()?.port
+        resolve()
+      })
+    })
+
+    // Basic socket handlers for testing
+    socketServer.on('connection', (socket) => {
+      socket.on('join-workflow', ({ workflowId }) => {
+        socket.join(workflowId)
+        socket.emit('joined-workflow', { workflowId })
+      })
+
+      socket.on('workflow-operation', (data) => {
+        socket.to(data.workflowId || 'test-workflow').emit('workflow-operation', {
+          ...data,
+          senderId: socket.id,
+        })
+      })
+    })
+  })
+
+  afterAll(async () => {
+    if (socketServer) {
+      socketServer.close()
+    }
+    if (httpServer) {
+      httpServer.close()
+    }
+  })
+
+  beforeEach(async () => {
+    // Create client socket for each test
+    clientSocket = io(`http://localhost:${serverPort}`, {
+      transports: ['polling', 'websocket'],
+    })
+
+    await new Promise<void>((resolve) => {
+      clientSocket.on('connect', () => {
+        resolve()
+      })
+    })
+  })
+
+  afterEach(() => {
+    if (clientSocket) {
+      clientSocket.close()
+    }
+  })
+
+  it('should connect to socket server', () => {
+    expect(clientSocket.connected).toBe(true)
+  })
+
+  it('should join workflow room', async () => {
+    const workflowId = 'test-workflow-123'
+
+    const joinedPromise = new Promise<void>((resolve) => {
+      clientSocket.on('joined-workflow', (data) => {
+        expect(data.workflowId).toBe(workflowId)
+        resolve()
+      })
+    })
+
+    clientSocket.emit('join-workflow', { workflowId })
+    await joinedPromise
+  })
+
+  it('should broadcast workflow operations', async () => {
+    const workflowId = 'test-workflow-456'
+
+    // Create second client
+    const client2 = io(`http://localhost:${serverPort}`)
+    await new Promise<void>((resolve) => {
+      client2.on('connect', resolve)
+    })
+
+    // Both clients join the same workflow
+    clientSocket.emit('join-workflow', { workflowId })
+    client2.emit('join-workflow', { workflowId })
+
+    // Wait for joins to complete
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    const operationPromise = new Promise<void>((resolve) => {
+      client2.on('workflow-operation', (data) => {
+        expect(data.operation).toBe('add')
+        expect(data.target).toBe('block')
+        expect(data.payload.id).toBe('block-123')
+        resolve()
+      })
+    })
+
+    // Client 1 sends operation
+    clientSocket.emit('workflow-operation', {
+      workflowId,
+      operation: 'add',
+      target: 'block',
+      payload: { id: 'block-123', type: 'action', name: 'Test Block' },
+      timestamp: Date.now(),
+    })
+
+    await operationPromise
+    client2.close()
+  })
+
+  it('should handle multiple concurrent connections', async () => {
+    const numClients = 10
+    const clients: Socket[] = []
+    const workflowId = 'stress-test-workflow'
+
+    // Create multiple clients
+    for (let i = 0; i < numClients; i++) {
+      const client = io(`http://localhost:${serverPort}`)
+      clients.push(client)
+
+      await new Promise<void>((resolve) => {
+        client.on('connect', resolve)
+      })
+
+      client.emit('join-workflow', { workflowId })
+    }
+
+    // Wait for all joins
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    let receivedCount = 0
+    const expectedCount = numClients - 1 // All except sender
+
+    const operationPromise = new Promise<void>((resolve) => {
+      clients.forEach((client, index) => {
+        if (index === 0) return // Skip sender
+
+        client.on('workflow-operation', () => {
+          receivedCount++
+          if (receivedCount === expectedCount) {
+            resolve()
+          }
+        })
+      })
+    })
+
+    // First client sends operation
+    clients[0].emit('workflow-operation', {
+      workflowId,
+      operation: 'add',
+      target: 'block',
+      payload: { id: 'stress-block', type: 'action' },
+      timestamp: Date.now(),
+    })
+
+    await operationPromise
+    expect(receivedCount).toBe(expectedCount)
+
+    // Clean up
+    clients.forEach((client) => client.close())
+  })
+
+  it('should handle rapid operations without loss', async () => {
+    const workflowId = 'rapid-test-workflow'
+    const numOperations = 50
+
+    const client2 = io(`http://localhost:${serverPort}`)
+    await new Promise<void>((resolve) => {
+      client2.on('connect', resolve)
+    })
+
+    clientSocket.emit('join-workflow', { workflowId })
+    client2.emit('join-workflow', { workflowId })
+
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    let receivedCount = 0
+    const receivedOperations = new Set<string>()
+
+    const operationsPromise = new Promise<void>((resolve) => {
+      client2.on('workflow-operation', (data) => {
+        receivedCount++
+        receivedOperations.add(data.payload.id)
+
+        if (receivedCount === numOperations) {
+          resolve()
+        }
+      })
+    })
+
+    // Send rapid operations
+    for (let i = 0; i < numOperations; i++) {
+      clientSocket.emit('workflow-operation', {
+        workflowId,
+        operation: 'add',
+        target: 'block',
+        payload: { id: `rapid-block-${i}`, type: 'action' },
+        timestamp: Date.now(),
+      })
+    }
+
+    await operationsPromise
+    expect(receivedCount).toBe(numOperations)
+    expect(receivedOperations.size).toBe(numOperations)
+
+    client2.close()
+  })
+})
diff --git a/bun.lock b/bun.lock
index 9be91bb90d7..2caa45c2fbd 100644
--- a/bun.lock
+++ b/bun.lock
@@ -8,6 +8,7 @@
         "@t3-oss/env-nextjs": "0.13.4",
         "@vercel/analytics": "1.5.0",
         "remark-gfm": "4.0.1",
+        "socket.io-client": "4.8.1",
       },
       "devDependencies": {
         "@biomejs/biome": "2.0.0-beta.5",
@@ -135,6 +136,7 @@
         "reactflow": "^11.11.4",
         "recharts": "2.15.3",
         "resend": "^4.1.2",
+        "socket.io": "^4.8.1",
         "stripe": "^17.7.0",
         "tailwind-merge": "^2.6.0",
         "tailwindcss-animate": "^1.0.7",
@@ -156,6 +158,7 @@
         "@types/xlsx": "0.0.36",
         "@vitejs/plugin-react": "^4.3.4",
         "@vitest/coverage-v8": "^3.0.8",
+        "concurrently": "^9.1.0",
         "critters": "^0.0.23",
         "dotenv": "^16.4.7",
         "drizzle-kit": "^0.31.1",
@@ -220,7 +223,7 @@
 
     "@ai-sdk/deepseek": ["@ai-sdk/deepseek@0.2.14", "", { "dependencies": { "@ai-sdk/openai-compatible": "0.2.14", "@ai-sdk/provider": "1.1.3", "@ai-sdk/provider-utils": "2.2.8" }, "peerDependencies": { "zod": "^3.0.0" } }, "sha512-TISD1FzBWuQkHEHoVustoJILV33ZNgfYxeTkq1xU2vHEZuWTGZV7/IlXixyFsfqDCdVgrbLeIABk5FuCw7niLg=="],
 
-    "@ai-sdk/google": ["@ai-sdk/google@1.2.18", "", { "dependencies": { "@ai-sdk/provider": "1.1.3", "@ai-sdk/provider-utils": "2.2.8" }, "peerDependencies": { "zod": "^3.0.0" } }, "sha512-8B70+i+uB12Ae6Sn6B9Oc6W0W/XorGgc88Nx0pyUrcxFOdytHBaAVhTPqYsO3LLClfjYN8pQ9GMxd5cpGEnUcA=="],
+    "@ai-sdk/google": ["@ai-sdk/google@1.2.19", "", { "dependencies": { "@ai-sdk/provider": "1.1.3", "@ai-sdk/provider-utils": "2.2.8" }, "peerDependencies": { "zod": "^3.0.0" } }, "sha512-Xgl6eftIRQ4srUdCzxM112JuewVMij5q4JLcNmHcB68Bxn9dpr3MVUSPlJwmameuiQuISIA8lMB+iRiRbFsaqA=="],
 
     "@ai-sdk/groq": ["@ai-sdk/groq@1.2.9", "", { "dependencies": { "@ai-sdk/provider": "1.1.3", "@ai-sdk/provider-utils": "2.2.8" }, "peerDependencies": { "zod": "^3.0.0" } }, "sha512-7MoDaxm8yWtiRbD1LipYZG0kBl+Xe0sv/EeyxnHnGPZappXdlgtdOgTZVjjXkT3nWP30jjZi9A45zoVrBMb3Xg=="],
 
@@ -270,31 +273,31 @@
 
     "@aws-crypto/util": ["@aws-crypto/util@5.2.0", "", { "dependencies": { "@aws-sdk/types": "^3.222.0", "@smithy/util-utf8": "^2.0.0", "tslib": "^2.6.2" } }, "sha512-4RkU9EsI6ZpBve5fseQlGNUWKMa1RLPQ1dnjnQoe07ldfIzcsGb5hC5W0Dm7u423KWzawlrpbjXBrXCEv9zazQ=="],
 
-    "@aws-sdk/client-s3": ["@aws-sdk/client-s3@3.821.0", "", { "dependencies": { "@aws-crypto/sha1-browser": "5.2.0", "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.821.0", "@aws-sdk/credential-provider-node": "3.821.0", "@aws-sdk/middleware-bucket-endpoint": "3.821.0", "@aws-sdk/middleware-expect-continue": "3.821.0", "@aws-sdk/middleware-flexible-checksums": "3.821.0", "@aws-sdk/middleware-host-header": "3.821.0", "@aws-sdk/middleware-location-constraint": "3.821.0", "@aws-sdk/middleware-logger": "3.821.0", "@aws-sdk/middleware-recursion-detection": "3.821.0", "@aws-sdk/middleware-sdk-s3": "3.821.0", "@aws-sdk/middleware-ssec": "3.821.0", "@aws-sdk/middleware-user-agent": "3.821.0", "@aws-sdk/region-config-resolver": "3.821.0", "@aws-sdk/signature-v4-multi-region": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.821.0", "@aws-sdk/util-user-agent-browser": "3.821.0", "@aws-sdk/util-user-agent-node": "3.821.0", "@aws-sdk/xml-builder": "3.821.0", "@smithy/config-resolver": "^4.1.4", "@smithy/core": "^3.5.1", "@smithy/eventstream-serde-browser": "^4.0.4", "@smithy/eventstream-serde-config-resolver": "^4.1.2", "@smithy/eventstream-serde-node": "^4.0.4", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/hash-blob-browser": "^4.0.4", "@smithy/hash-node": "^4.0.4", "@smithy/hash-stream-node": "^4.0.4", "@smithy/invalid-dependency": "^4.0.4", "@smithy/md5-js": "^4.0.4", "@smithy/middleware-content-length": "^4.0.4", "@smithy/middleware-endpoint": "^4.1.9", "@smithy/middleware-retry": "^4.1.10", "@smithy/middleware-serde": "^4.0.8", "@smithy/middleware-stack": "^4.0.4", "@smithy/node-config-provider": "^4.1.3", "@smithy/node-http-handler": "^4.0.6", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-body-length-node": "^4.0.0", "@smithy/util-defaults-mode-browser": "^4.0.17", "@smithy/util-defaults-mode-node": "^4.0.17", "@smithy/util-endpoints": "^3.0.6", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "@smithy/util-waiter": "^4.0.5", "tslib": "^2.6.2" } }, "sha512-enlFiONQD+oCaV+C6hMsAJvyQRT3wZmCtXXq7qjxX8BiLgXsHQ9HHS+Nhoq08Ya6mtd1Y1qHOOYpnD8yyUzTMQ=="],
+    "@aws-sdk/client-s3": ["@aws-sdk/client-s3@3.832.0", "", { "dependencies": { "@aws-crypto/sha1-browser": "5.2.0", "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.826.0", "@aws-sdk/credential-provider-node": "3.830.0", "@aws-sdk/middleware-bucket-endpoint": "3.830.0", "@aws-sdk/middleware-expect-continue": "3.821.0", "@aws-sdk/middleware-flexible-checksums": "3.826.0", "@aws-sdk/middleware-host-header": "3.821.0", "@aws-sdk/middleware-location-constraint": "3.821.0", "@aws-sdk/middleware-logger": "3.821.0", "@aws-sdk/middleware-recursion-detection": "3.821.0", "@aws-sdk/middleware-sdk-s3": "3.826.0", "@aws-sdk/middleware-ssec": "3.821.0", "@aws-sdk/middleware-user-agent": "3.828.0", "@aws-sdk/region-config-resolver": "3.821.0", "@aws-sdk/signature-v4-multi-region": "3.826.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.828.0", "@aws-sdk/util-user-agent-browser": "3.821.0", "@aws-sdk/util-user-agent-node": "3.828.0", "@aws-sdk/xml-builder": "3.821.0", "@smithy/config-resolver": "^4.1.4", "@smithy/core": "^3.5.3", "@smithy/eventstream-serde-browser": "^4.0.4", "@smithy/eventstream-serde-config-resolver": "^4.1.2", "@smithy/eventstream-serde-node": "^4.0.4", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/hash-blob-browser": "^4.0.4", "@smithy/hash-node": "^4.0.4", "@smithy/hash-stream-node": "^4.0.4", "@smithy/invalid-dependency": "^4.0.4", "@smithy/md5-js": "^4.0.4", "@smithy/middleware-content-length": "^4.0.4", "@smithy/middleware-endpoint": "^4.1.11", "@smithy/middleware-retry": "^4.1.12", "@smithy/middleware-serde": "^4.0.8", "@smithy/middleware-stack": "^4.0.4", "@smithy/node-config-provider": "^4.1.3", "@smithy/node-http-handler": "^4.0.6", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-body-length-node": "^4.0.0", "@smithy/util-defaults-mode-browser": "^4.0.19", "@smithy/util-defaults-mode-node": "^4.0.19", "@smithy/util-endpoints": "^3.0.6", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "@smithy/util-waiter": "^4.0.5", "@types/uuid": "^9.0.1", "tslib": "^2.6.2", "uuid": "^9.0.1" } }, "sha512-S+md1zCe71SEuaRDuLHq4mzhYYkVxR1ENa8NwrgInfYoC4xo8/pESoR6i0ZZpcLs0Jw4EyVInWYs4GgDHW70qQ=="],
 
-    "@aws-sdk/client-sso": ["@aws-sdk/client-sso@3.821.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.821.0", "@aws-sdk/middleware-host-header": "3.821.0", "@aws-sdk/middleware-logger": "3.821.0", "@aws-sdk/middleware-recursion-detection": "3.821.0", "@aws-sdk/middleware-user-agent": "3.821.0", "@aws-sdk/region-config-resolver": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.821.0", "@aws-sdk/util-user-agent-browser": "3.821.0", "@aws-sdk/util-user-agent-node": "3.821.0", "@smithy/config-resolver": "^4.1.4", "@smithy/core": "^3.5.1", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/hash-node": "^4.0.4", "@smithy/invalid-dependency": "^4.0.4", "@smithy/middleware-content-length": "^4.0.4", "@smithy/middleware-endpoint": "^4.1.9", "@smithy/middleware-retry": "^4.1.10", "@smithy/middleware-serde": "^4.0.8", "@smithy/middleware-stack": "^4.0.4", "@smithy/node-config-provider": "^4.1.3", "@smithy/node-http-handler": "^4.0.6", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-body-length-node": "^4.0.0", "@smithy/util-defaults-mode-browser": "^4.0.17", "@smithy/util-defaults-mode-node": "^4.0.17", "@smithy/util-endpoints": "^3.0.6", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-aDEBZUKUd/+Tvudi0d9KQlqt2OW2P27LATZX0jkNC8yVk4145bAPS04EYoqdKLuyUn/U33DibEOgKUpxZB12jQ=="],
+    "@aws-sdk/client-sso": ["@aws-sdk/client-sso@3.830.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.826.0", "@aws-sdk/middleware-host-header": "3.821.0", "@aws-sdk/middleware-logger": "3.821.0", "@aws-sdk/middleware-recursion-detection": "3.821.0", "@aws-sdk/middleware-user-agent": "3.828.0", "@aws-sdk/region-config-resolver": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.828.0", "@aws-sdk/util-user-agent-browser": "3.821.0", "@aws-sdk/util-user-agent-node": "3.828.0", "@smithy/config-resolver": "^4.1.4", "@smithy/core": "^3.5.3", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/hash-node": "^4.0.4", "@smithy/invalid-dependency": "^4.0.4", "@smithy/middleware-content-length": "^4.0.4", "@smithy/middleware-endpoint": "^4.1.11", "@smithy/middleware-retry": "^4.1.12", "@smithy/middleware-serde": "^4.0.8", "@smithy/middleware-stack": "^4.0.4", "@smithy/node-config-provider": "^4.1.3", "@smithy/node-http-handler": "^4.0.6", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-body-length-node": "^4.0.0", "@smithy/util-defaults-mode-browser": "^4.0.19", "@smithy/util-defaults-mode-node": "^4.0.19", "@smithy/util-endpoints": "^3.0.6", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-5zCEpfI+zwX2SIa258L+TItNbBoAvQQ6w74qdFM6YJufQ1F9tvwjTX8T+eSTT9nsFIvfYnUaGalWwJVfmJUgVQ=="],
 
-    "@aws-sdk/core": ["@aws-sdk/core@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/core": "^3.5.1", "@smithy/node-config-provider": "^4.1.3", "@smithy/property-provider": "^4.0.4", "@smithy/protocol-http": "^5.1.2", "@smithy/signature-v4": "^5.1.2", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "@smithy/util-middleware": "^4.0.4", "fast-xml-parser": "4.4.1", "tslib": "^2.6.2" } }, "sha512-8eB3wKbmfciQFmxFq7hAjy7mXdUs7vBOR5SwT0ZtQBg0Txc18Lc9tMViqqdO6/KU7OukA6ib2IAVSjIJJEN7FQ=="],
+    "@aws-sdk/core": ["@aws-sdk/core@3.826.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@aws-sdk/xml-builder": "3.821.0", "@smithy/core": "^3.5.3", "@smithy/node-config-provider": "^4.1.3", "@smithy/property-provider": "^4.0.4", "@smithy/protocol-http": "^5.1.2", "@smithy/signature-v4": "^5.1.2", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "@smithy/util-utf8": "^4.0.0", "fast-xml-parser": "4.4.1", "tslib": "^2.6.2" } }, "sha512-BGbQYzWj3ps+dblq33FY5tz/SsgJCcXX0zjQlSC07tYvU1jHTUvsefphyig+fY38xZ4wdKjbTop+KUmXUYrOXw=="],
 
-    "@aws-sdk/credential-provider-env": ["@aws-sdk/credential-provider-env@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-C+s/A72pd7CXwEsJj9+Uq9T726iIfIF18hGRY8o82xcIEfOyakiPnlisku8zZOaAu+jm0CihbbYN4NyYNQ+HZQ=="],
+    "@aws-sdk/credential-provider-env": ["@aws-sdk/credential-provider-env@3.826.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-DK3pQY8+iKK3MGDdC3uOZQ2psU01obaKlTYhEwNu4VWzgwQL4Vi3sWj4xSWGEK41vqZxiRLq6fOq7ysRI+qEZA=="],
 
-    "@aws-sdk/credential-provider-http": ["@aws-sdk/credential-provider-http@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/node-http-handler": "^4.0.6", "@smithy/property-provider": "^4.0.4", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "@smithy/util-stream": "^4.2.2", "tslib": "^2.6.2" } }, "sha512-gIRzTLnAsRfRSNarCag7G7rhcHagz4x5nNTWRihQs5cwTOghEExDy7Tj5m4TEkv3dcTAsNn+l4tnR4nZXo6R+Q=="],
+    "@aws-sdk/credential-provider-http": ["@aws-sdk/credential-provider-http@3.826.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/types": "3.821.0", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/node-http-handler": "^4.0.6", "@smithy/property-provider": "^4.0.4", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "@smithy/util-stream": "^4.2.2", "tslib": "^2.6.2" } }, "sha512-N+IVZBh+yx/9GbMZTKO/gErBi/FYZQtcFRItoLbY+6WU+0cSWyZYfkoeOxHmQV3iX9k65oljERIWUmL9x6OSQg=="],
 
-    "@aws-sdk/credential-provider-ini": ["@aws-sdk/credential-provider-ini@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/credential-provider-env": "3.821.0", "@aws-sdk/credential-provider-http": "3.821.0", "@aws-sdk/credential-provider-process": "3.821.0", "@aws-sdk/credential-provider-sso": "3.821.0", "@aws-sdk/credential-provider-web-identity": "3.821.0", "@aws-sdk/nested-clients": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/credential-provider-imds": "^4.0.6", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-VRTrmsca8kBHtY1tTek1ce+XkK/H0fzodBKcilM/qXjTyumMHPAzVAxKZfSvGC+28/pXyQzhOEyxZfw7giCiWA=="],
+    "@aws-sdk/credential-provider-ini": ["@aws-sdk/credential-provider-ini@3.830.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/credential-provider-env": "3.826.0", "@aws-sdk/credential-provider-http": "3.826.0", "@aws-sdk/credential-provider-process": "3.826.0", "@aws-sdk/credential-provider-sso": "3.830.0", "@aws-sdk/credential-provider-web-identity": "3.830.0", "@aws-sdk/nested-clients": "3.830.0", "@aws-sdk/types": "3.821.0", "@smithy/credential-provider-imds": "^4.0.6", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-zeQenzvh8JRY5nULd8izdjVGoCM1tgsVVsrLSwDkHxZTTW0hW/bmOmXfvdaE0wDdomXW7m2CkQDSmP7XdvNXZg=="],
 
-    "@aws-sdk/credential-provider-node": ["@aws-sdk/credential-provider-node@3.821.0", "", { "dependencies": { "@aws-sdk/credential-provider-env": "3.821.0", "@aws-sdk/credential-provider-http": "3.821.0", "@aws-sdk/credential-provider-ini": "3.821.0", "@aws-sdk/credential-provider-process": "3.821.0", "@aws-sdk/credential-provider-sso": "3.821.0", "@aws-sdk/credential-provider-web-identity": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/credential-provider-imds": "^4.0.6", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-oBgbcgOXWMgknAfhIdTeHSSVIv+k2LXN9oTbxu1r++o4WWBWrEQ8mHU0Zo9dfr7Uaoqi3pezYZznsBkXnMLEOg=="],
+    "@aws-sdk/credential-provider-node": ["@aws-sdk/credential-provider-node@3.830.0", "", { "dependencies": { "@aws-sdk/credential-provider-env": "3.826.0", "@aws-sdk/credential-provider-http": "3.826.0", "@aws-sdk/credential-provider-ini": "3.830.0", "@aws-sdk/credential-provider-process": "3.826.0", "@aws-sdk/credential-provider-sso": "3.830.0", "@aws-sdk/credential-provider-web-identity": "3.830.0", "@aws-sdk/types": "3.821.0", "@smithy/credential-provider-imds": "^4.0.6", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-X/2LrTgwtK1pkWrvofxQBI8VTi6QVLtSMpsKKPPnJQ0vgqC0e4czSIs3ZxiEsOkCBaQ2usXSiKyh0ccsQ6k2OA=="],
 
-    "@aws-sdk/credential-provider-process": ["@aws-sdk/credential-provider-process@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-e18ucfqKB3ICNj5RP/FEdvUfhVK6E9MALOsl8pKP13mwegug46p/1BsZWACD5n+Zf9ViiiHxIO7td03zQixfwA=="],
+    "@aws-sdk/credential-provider-process": ["@aws-sdk/credential-provider-process@3.826.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-kURrc4amu3NLtw1yZw7EoLNEVhmOMRUTs+chaNcmS+ERm3yK0nKjaJzmKahmwlTQTSl3wJ8jjK7x962VPo+zWw=="],
 
-    "@aws-sdk/credential-provider-sso": ["@aws-sdk/credential-provider-sso@3.821.0", "", { "dependencies": { "@aws-sdk/client-sso": "3.821.0", "@aws-sdk/core": "3.821.0", "@aws-sdk/token-providers": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-Dt+pheBLom4O/egO4L75/72k9C1qtUOLl0F0h6lmqZe4Mvhz+wDtjoO/MdGC/P1q0kcIX/bBKr0NQ3cIvAH8pA=="],
+    "@aws-sdk/credential-provider-sso": ["@aws-sdk/credential-provider-sso@3.830.0", "", { "dependencies": { "@aws-sdk/client-sso": "3.830.0", "@aws-sdk/core": "3.826.0", "@aws-sdk/token-providers": "3.830.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-+VdRpZmfekzpySqZikAKx6l5ndnLGluioIgUG4ZznrButgFD/iogzFtGmBDFB3ZLViX1l4pMXru0zFwJEZT21Q=="],
 
-    "@aws-sdk/credential-provider-web-identity": ["@aws-sdk/credential-provider-web-identity@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/nested-clients": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-FF5wnRJkxSQaCVVvWNv53K1MhTMgH8d+O+MHTbkv51gVIgVATrtfFQMKBLcEAxzXrgAliIO3LiNv+1TqqBZ+BA=="],
+    "@aws-sdk/credential-provider-web-identity": ["@aws-sdk/credential-provider-web-identity@3.830.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/nested-clients": "3.830.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-hPYrKsZeeOdLROJ59T6Y8yZ0iwC/60L3qhZXjapBFjbqBtMaQiMTI645K6xVXBioA6vxXq7B4aLOhYqk6Fy/Ww=="],
 
-    "@aws-sdk/middleware-bucket-endpoint": ["@aws-sdk/middleware-bucket-endpoint@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@aws-sdk/util-arn-parser": "3.804.0", "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-config-provider": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-cebgeytKlWOgGczLo3BPvNY9XlzAzGZQANSysgJ2/8PSldmUpXRIF+GKPXDVhXeInWYHIfB8zZi3RqrPoXcNYQ=="],
+    "@aws-sdk/middleware-bucket-endpoint": ["@aws-sdk/middleware-bucket-endpoint@3.830.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@aws-sdk/util-arn-parser": "3.804.0", "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-config-provider": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-ElVeCReZSH5Ds+/pkL5ebneJjuo8f49e9JXV1cYizuH0OAOQfYaBU9+M+7+rn61pTttOFE8W//qKzrXBBJhfMg=="],
 
     "@aws-sdk/middleware-expect-continue": ["@aws-sdk/middleware-expect-continue@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-zAOoSZKe1njOrtynvK6ZORU57YGv5I7KP4+rwOvUN3ZhJbQ7QPf8gKtFUCYAPRMegaXCKF/ADPtDZBAmM+zZ9g=="],
 
-    "@aws-sdk/middleware-flexible-checksums": ["@aws-sdk/middleware-flexible-checksums@3.821.0", "", { "dependencies": { "@aws-crypto/crc32": "5.2.0", "@aws-crypto/crc32c": "5.2.0", "@aws-crypto/util": "5.2.0", "@aws-sdk/core": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/is-array-buffer": "^4.0.0", "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-middleware": "^4.0.4", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-C56sBHXq1fEsLfIAup+w/7SKtb6d8Mb3YBec94r2ludVn1s3ypYWRovFE/6VhUzvwUbTQaxfrA2ewy5GQ1/DJQ=="],
+    "@aws-sdk/middleware-flexible-checksums": ["@aws-sdk/middleware-flexible-checksums@3.826.0", "", { "dependencies": { "@aws-crypto/crc32": "5.2.0", "@aws-crypto/crc32c": "5.2.0", "@aws-crypto/util": "5.2.0", "@aws-sdk/core": "3.826.0", "@aws-sdk/types": "3.821.0", "@smithy/is-array-buffer": "^4.0.0", "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-middleware": "^4.0.4", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-Fz9w8CFYPfSlHEB6feSsi06hdS+s+FB8k5pO4L7IV0tUa78mlhxF/VNlAJaVWYyOkZXl4HPH2K48aapACSQOXw=="],
 
     "@aws-sdk/middleware-host-header": ["@aws-sdk/middleware-host-header@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-xSMR+sopSeWGx5/4pAGhhfMvGBHioVBbqGvDs6pG64xfNwM5vq5s5v6D04e2i+uSTj4qGa71dLUs5I0UzAK3sw=="],
 
@@ -304,27 +307,27 @@
 
     "@aws-sdk/middleware-recursion-detection": ["@aws-sdk/middleware-recursion-detection@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-efmaifbhBoqKG3bAoEfDdcM8hn1psF+4qa7ykWuYmfmah59JBeqHLfz5W9m9JoTwoKPkFcVLWZxnyZzAnVBOIg=="],
 
-    "@aws-sdk/middleware-sdk-s3": ["@aws-sdk/middleware-sdk-s3@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-arn-parser": "3.804.0", "@smithy/core": "^3.5.1", "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/signature-v4": "^5.1.2", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "@smithy/util-config-provider": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-D469De1d4NtcCTVHzUL2Q0tGvPFr7mk2j4+oCYpVyd5awSSOyl8Adkxse8qayZj9ROmuMlsoU5VhBvcc9Hoo2w=="],
+    "@aws-sdk/middleware-sdk-s3": ["@aws-sdk/middleware-sdk-s3@3.826.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-arn-parser": "3.804.0", "@smithy/core": "^3.5.3", "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/signature-v4": "^5.1.2", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "@smithy/util-config-provider": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-8F0qWaYKfvD/de1AKccXuigM+gb/IZSncCqxdnFWqd+TFzo9qI9Hh+TpUhWOMYSgxsMsYQ8ipmLzlD/lDhjrmA=="],
 
     "@aws-sdk/middleware-ssec": ["@aws-sdk/middleware-ssec@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-YYi1Hhr2AYiU/24cQc8HIB+SWbQo6FBkMYojVuz/zgrtkFmALxENGF/21OPg7f/QWd+eadZJRxCjmRwh5F2Cxg=="],
 
-    "@aws-sdk/middleware-user-agent": ["@aws-sdk/middleware-user-agent@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.821.0", "@smithy/core": "^3.5.1", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-rw8q3TxygMg3VrofN04QyWVCCyGwz3bVthYmBZZseENPWG3Krz1OCKcyqjkTcAxMQlEywOske+GIiOasGKnJ3w=="],
+    "@aws-sdk/middleware-user-agent": ["@aws-sdk/middleware-user-agent@3.828.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.828.0", "@smithy/core": "^3.5.3", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-nixvI/SETXRdmrVab4D9LvXT3lrXkwAWGWk2GVvQvzlqN1/M/RfClj+o37Sn4FqRkGH9o9g7Fqb1YqZ4mqDAtA=="],
 
-    "@aws-sdk/nested-clients": ["@aws-sdk/nested-clients@3.821.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.821.0", "@aws-sdk/middleware-host-header": "3.821.0", "@aws-sdk/middleware-logger": "3.821.0", "@aws-sdk/middleware-recursion-detection": "3.821.0", "@aws-sdk/middleware-user-agent": "3.821.0", "@aws-sdk/region-config-resolver": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.821.0", "@aws-sdk/util-user-agent-browser": "3.821.0", "@aws-sdk/util-user-agent-node": "3.821.0", "@smithy/config-resolver": "^4.1.4", "@smithy/core": "^3.5.1", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/hash-node": "^4.0.4", "@smithy/invalid-dependency": "^4.0.4", "@smithy/middleware-content-length": "^4.0.4", "@smithy/middleware-endpoint": "^4.1.9", "@smithy/middleware-retry": "^4.1.10", "@smithy/middleware-serde": "^4.0.8", "@smithy/middleware-stack": "^4.0.4", "@smithy/node-config-provider": "^4.1.3", "@smithy/node-http-handler": "^4.0.6", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-body-length-node": "^4.0.0", "@smithy/util-defaults-mode-browser": "^4.0.17", "@smithy/util-defaults-mode-node": "^4.0.17", "@smithy/util-endpoints": "^3.0.6", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-2IuHcUsWw44ftSEDYU4dvktTEqgyDvkOcfpoGC/UmT4Qo6TVCP3U5tWEGpNK9nN+7nLvekruxxG/jaMt5/oWVw=="],
+    "@aws-sdk/nested-clients": ["@aws-sdk/nested-clients@3.830.0", "", { "dependencies": { "@aws-crypto/sha256-browser": "5.2.0", "@aws-crypto/sha256-js": "5.2.0", "@aws-sdk/core": "3.826.0", "@aws-sdk/middleware-host-header": "3.821.0", "@aws-sdk/middleware-logger": "3.821.0", "@aws-sdk/middleware-recursion-detection": "3.821.0", "@aws-sdk/middleware-user-agent": "3.828.0", "@aws-sdk/region-config-resolver": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-endpoints": "3.828.0", "@aws-sdk/util-user-agent-browser": "3.821.0", "@aws-sdk/util-user-agent-node": "3.828.0", "@smithy/config-resolver": "^4.1.4", "@smithy/core": "^3.5.3", "@smithy/fetch-http-handler": "^5.0.4", "@smithy/hash-node": "^4.0.4", "@smithy/invalid-dependency": "^4.0.4", "@smithy/middleware-content-length": "^4.0.4", "@smithy/middleware-endpoint": "^4.1.11", "@smithy/middleware-retry": "^4.1.12", "@smithy/middleware-serde": "^4.0.8", "@smithy/middleware-stack": "^4.0.4", "@smithy/node-config-provider": "^4.1.3", "@smithy/node-http-handler": "^4.0.6", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-body-length-node": "^4.0.0", "@smithy/util-defaults-mode-browser": "^4.0.19", "@smithy/util-defaults-mode-node": "^4.0.19", "@smithy/util-endpoints": "^3.0.6", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-5N5YTlBr1vtxf7+t+UaIQ625KEAmm7fY9o1e3MgGOi/paBoI0+axr3ud24qLIy0NSzFlAHEaxUSWxcERNjIoZw=="],
 
     "@aws-sdk/region-config-resolver": ["@aws-sdk/region-config-resolver@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/node-config-provider": "^4.1.3", "@smithy/types": "^4.3.1", "@smithy/util-config-provider": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "tslib": "^2.6.2" } }, "sha512-t8og+lRCIIy5nlId0bScNpCkif8sc0LhmtaKsbm0ZPm3sCa/WhCbSZibjbZ28FNjVCV+p0D9RYZx0VDDbtWyjw=="],
 
-    "@aws-sdk/s3-request-presigner": ["@aws-sdk/s3-request-presigner@3.821.0", "", { "dependencies": { "@aws-sdk/signature-v4-multi-region": "3.821.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-format-url": "3.821.0", "@smithy/middleware-endpoint": "^4.1.9", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-VLM0pWQxEBf80uKirU4B1hQz3ZYX5OaPFrRSciUkkKYdqPFrnjQ7NyIQRjF1MVmXwsKgBxJVWl+p0BKcsHR+rQ=="],
+    "@aws-sdk/s3-request-presigner": ["@aws-sdk/s3-request-presigner@3.832.0", "", { "dependencies": { "@aws-sdk/signature-v4-multi-region": "3.826.0", "@aws-sdk/types": "3.821.0", "@aws-sdk/util-format-url": "3.821.0", "@smithy/middleware-endpoint": "^4.1.11", "@smithy/protocol-http": "^5.1.2", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-zXuwfaAYu99LUF7/6iBr3UlKCMaMImBwfmLXJQlvtE3ebrERXQuISME9Vjd2oG+hJ6XcX6RJqkeIvZBytMzvRw=="],
 
-    "@aws-sdk/signature-v4-multi-region": ["@aws-sdk/signature-v4-multi-region@3.821.0", "", { "dependencies": { "@aws-sdk/middleware-sdk-s3": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/protocol-http": "^5.1.2", "@smithy/signature-v4": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-UjfyVR/PB/TP9qe1x6tv7qLlD8/0eiSLDkkBUgBmddkkX0l17oy9c2SJINuV3jy1fbx6KORZ6gyvRZ2nb8dtMw=="],
+    "@aws-sdk/signature-v4-multi-region": ["@aws-sdk/signature-v4-multi-region@3.826.0", "", { "dependencies": { "@aws-sdk/middleware-sdk-s3": "3.826.0", "@aws-sdk/types": "3.821.0", "@smithy/protocol-http": "^5.1.2", "@smithy/signature-v4": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-3fEi/zy6tpMzomYosksGtu7jZqGFcdBXoL7YRsG7OEeQzBbOW9B+fVaQZ4jnsViSjzA/yKydLahMrfPnt+iaxg=="],
 
-    "@aws-sdk/token-providers": ["@aws-sdk/token-providers@3.821.0", "", { "dependencies": { "@aws-sdk/core": "3.821.0", "@aws-sdk/nested-clients": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-qJ7wgKhdxGbPg718zWXbCYKDuSWZNU3TSw64hPRW6FtbZrIyZxObpiTKC6DKwfsVoZZhHEoP/imGykN1OdOTJA=="],
+    "@aws-sdk/token-providers": ["@aws-sdk/token-providers@3.830.0", "", { "dependencies": { "@aws-sdk/core": "3.826.0", "@aws-sdk/nested-clients": "3.830.0", "@aws-sdk/types": "3.821.0", "@smithy/property-provider": "^4.0.4", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-aJ4guFwj92nV9D+EgJPaCFKK0I3y2uMchiDfh69Zqnmwfxxxfxat6F79VA7PS0BdbjRfhLbn+Ghjftnomu2c1g=="],
 
     "@aws-sdk/types": ["@aws-sdk/types@3.821.0", "", { "dependencies": { "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-Znroqdai1a90TlxGaJ+FK1lwC0fHpo97Xjsp5UKGR5JODYm7f9+/fF17ebO1KdoBr/Rm0UIFiF5VmI8ts9F1eA=="],
 
     "@aws-sdk/util-arn-parser": ["@aws-sdk/util-arn-parser@3.804.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-wmBJqn1DRXnZu3b4EkE6CWnoWMo1ZMvlfkqU5zPz67xx1GMaXlDCchFvKAXMjk4jn/L1O3tKnoFDNsoLV1kgNQ=="],
 
-    "@aws-sdk/util-endpoints": ["@aws-sdk/util-endpoints@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/types": "^4.3.1", "@smithy/util-endpoints": "^3.0.6", "tslib": "^2.6.2" } }, "sha512-Uknt/zUZnLE76zaAAPEayOeF5/4IZ2puTFXvcSCWHsi9m3tqbb9UozlnlVqvCZLCRWfQryZQoG2W4XSS3qgk5A=="],
+    "@aws-sdk/util-endpoints": ["@aws-sdk/util-endpoints@3.828.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/types": "^4.3.1", "@smithy/util-endpoints": "^3.0.6", "tslib": "^2.6.2" } }, "sha512-RvKch111SblqdkPzg3oCIdlGxlQs+k+P7Etory9FmxPHyPDvsP1j1c74PmgYqtzzMWmoXTjd+c9naUHh9xG8xg=="],
 
     "@aws-sdk/util-format-url": ["@aws-sdk/util-format-url@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/querystring-builder": "^4.0.4", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-h+xqmPToxDrZ0a7rxE1a8Oh4zpWfZe9oiQUphGtfiGFA6j75UiURH5J3MmGHa/G4t15I3iLLbYtUXxvb1i7evg=="],
 
@@ -332,7 +335,7 @@
 
     "@aws-sdk/util-user-agent-browser": ["@aws-sdk/util-user-agent-browser@3.821.0", "", { "dependencies": { "@aws-sdk/types": "3.821.0", "@smithy/types": "^4.3.1", "bowser": "^2.11.0", "tslib": "^2.6.2" } }, "sha512-irWZHyM0Jr1xhC+38OuZ7JB6OXMLPZlj48thElpsO1ZSLRkLZx5+I7VV6k3sp2yZ7BYbKz/G2ojSv4wdm7XTLw=="],
 
-    "@aws-sdk/util-user-agent-node": ["@aws-sdk/util-user-agent-node@3.821.0", "", { "dependencies": { "@aws-sdk/middleware-user-agent": "3.821.0", "@aws-sdk/types": "3.821.0", "@smithy/node-config-provider": "^4.1.3", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" }, "peerDependencies": { "aws-crt": ">=1.0.0" }, "optionalPeers": ["aws-crt"] }, "sha512-YwMXc9EvuzJgnLBTyiQly2juPujXwDgcMHB0iSN92tHe7Dd1jJ1feBmTgdClaaqCeHFUaFpw+3JU/ZUJ6LjR+A=="],
+    "@aws-sdk/util-user-agent-node": ["@aws-sdk/util-user-agent-node@3.828.0", "", { "dependencies": { "@aws-sdk/middleware-user-agent": "3.828.0", "@aws-sdk/types": "3.821.0", "@smithy/node-config-provider": "^4.1.3", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" }, "peerDependencies": { "aws-crt": ">=1.0.0" }, "optionalPeers": ["aws-crt"] }, "sha512-LdN6fTBzTlQmc8O8f1wiZN0qF3yBWVGis7NwpWK7FUEzP9bEZRxYfIkV9oV9zpt6iNRze1SedK3JQVB/udxBoA=="],
 
     "@aws-sdk/xml-builder": ["@aws-sdk/xml-builder@3.821.0", "", { "dependencies": { "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-DIIotRnefVL6DiaHtO6/21DhJ4JZnnIwdNbpwiAhdt/AVbttcE4yw925gsjur0OGv5BTYXQXU3YnANBYnZjuQA=="],
 
@@ -362,11 +365,11 @@
 
     "@babel/code-frame": ["@babel/code-frame@7.27.1", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.27.1", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg=="],
 
-    "@babel/compat-data": ["@babel/compat-data@7.27.3", "", {}, "sha512-V42wFfx1ymFte+ecf6iXghnnP8kWTO+ZLXIyZq+1LAXHHvTZdVxicn4yiVYdYMGaCO3tmqub11AorKkv+iodqw=="],
+    "@babel/compat-data": ["@babel/compat-data@7.27.5", "", {}, "sha512-KiRAp/VoJaWkkte84TvUd9qjdbZAdiqyvMxrGl1N6vzFogKmaLgoM3L1kgtLicp2HP5fBJS8JrZKLVIZGVJAVg=="],
 
     "@babel/core": ["@babel/core@7.27.4", "", { "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.27.3", "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-module-transforms": "^7.27.3", "@babel/helpers": "^7.27.4", "@babel/parser": "^7.27.4", "@babel/template": "^7.27.2", "@babel/traverse": "^7.27.4", "@babel/types": "^7.27.3", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", "json5": "^2.2.3", "semver": "^6.3.1" } }, "sha512-bXYxrXFubeYdvB0NhD/NBB3Qi6aZeV20GOWVI47t2dkecCEoneR4NPVcb7abpXDEvejgrUfFtG6vG/zxAKmg+g=="],
 
-    "@babel/generator": ["@babel/generator@7.27.3", "", { "dependencies": { "@babel/parser": "^7.27.3", "@babel/types": "^7.27.3", "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.25", "jsesc": "^3.0.2" } }, "sha512-xnlJYj5zepml8NXtjkG0WquFUv8RskFqyFcVgTBp5k+NaA/8uw/K+OSVf8AMGw5e9HKP2ETd5xpK5MLZQD6b4Q=="],
+    "@babel/generator": ["@babel/generator@7.27.5", "", { "dependencies": { "@babel/parser": "^7.27.5", "@babel/types": "^7.27.3", "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.25", "jsesc": "^3.0.2" } }, "sha512-ZGhA37l0e/g2s1Cnzdix0O3aLYm66eF8aufiVteOgnwxgnRP8GoyMj7VWsgWnQbVKXyge7hqrFh2K2TQM6t1Hw=="],
 
     "@babel/helper-compilation-targets": ["@babel/helper-compilation-targets@7.27.2", "", { "dependencies": { "@babel/compat-data": "^7.27.2", "@babel/helper-validator-option": "^7.27.1", "browserslist": "^4.24.0", "lru-cache": "^5.1.1", "semver": "^6.3.1" } }, "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ=="],
 
@@ -382,25 +385,25 @@
 
     "@babel/helper-validator-option": ["@babel/helper-validator-option@7.27.1", "", {}, "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg=="],
 
-    "@babel/helpers": ["@babel/helpers@7.27.4", "", { "dependencies": { "@babel/template": "^7.27.2", "@babel/types": "^7.27.3" } }, "sha512-Y+bO6U+I7ZKaM5G5rDUZiYfUvQPUibYmAFe7EnKdnKBbVXDZxvp+MWOH5gYciY0EPk4EScsuFMQBbEfpdRKSCQ=="],
+    "@babel/helpers": ["@babel/helpers@7.27.6", "", { "dependencies": { "@babel/template": "^7.27.2", "@babel/types": "^7.27.6" } }, "sha512-muE8Tt8M22638HU31A3CgfSUciwz1fhATfoVai05aPXGor//CdWDCbnlY1yvBPo07njuVOCNGCSp/GTt12lIug=="],
 
-    "@babel/parser": ["@babel/parser@7.27.4", "", { "dependencies": { "@babel/types": "^7.27.3" }, "bin": "./bin/babel-parser.js" }, "sha512-BRmLHGwpUqLFR2jzx9orBuX/ABDkj2jLKOXrHDTN2aOKL+jFDDKaRNo9nyYsIl9h/UE/7lMKdDjKQQyxKKDZ7g=="],
+    "@babel/parser": ["@babel/parser@7.27.5", "", { "dependencies": { "@babel/types": "^7.27.3" }, "bin": "./bin/babel-parser.js" }, "sha512-OsQd175SxWkGlzbny8J3K8TnnDD0N3lrIUtB92xwyRpzaenGZhxDvxN/JgU00U3CDZNj9tPuDJ5H0WS4Nt3vKg=="],
 
     "@babel/plugin-transform-react-jsx-self": ["@babel/plugin-transform-react-jsx-self@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw=="],
 
     "@babel/plugin-transform-react-jsx-source": ["@babel/plugin-transform-react-jsx-source@7.27.1", "", { "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw=="],
 
-    "@babel/runtime": ["@babel/runtime@7.27.4", "", {}, "sha512-t3yaEOuGu9NlIZ+hIeGbBjFtZT7j2cb2tg0fuaJKeGotchRjjLfrBA9Kwf8quhpP1EUuxModQg04q/mBwyg8uA=="],
+    "@babel/runtime": ["@babel/runtime@7.27.6", "", {}, "sha512-vbavdySgbTTrmFE+EsiqUTzlOr5bzlnJtUv9PynGCAKvfQqjIXbvFdumPM/GxMDfyuGMJaJAU6TO4zc1Jf1i8Q=="],
 
     "@babel/template": ["@babel/template@7.27.2", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/parser": "^7.27.2", "@babel/types": "^7.27.1" } }, "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw=="],
 
     "@babel/traverse": ["@babel/traverse@7.27.4", "", { "dependencies": { "@babel/code-frame": "^7.27.1", "@babel/generator": "^7.27.3", "@babel/parser": "^7.27.4", "@babel/template": "^7.27.2", "@babel/types": "^7.27.3", "debug": "^4.3.1", "globals": "^11.1.0" } }, "sha512-oNcu2QbHqts9BtOWJosOVJapWjBDSxGCpFvikNR5TGDYDQf3JwpIoMzIKrvfoti93cLfPJEG4tH9SPVeyCGgdA=="],
 
-    "@babel/types": ["@babel/types@7.27.3", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-Y1GkI4ktrtvmawoSq+4FCVHNryea6uR+qUQy0AGxLSsjCX0nVmkYQMBLHDkXZuo5hGx7eYdnIaslsdBFm7zbUw=="],
+    "@babel/types": ["@babel/types@7.27.6", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-ETyHEk2VHHvl9b9jZP5IHPavHYk57EhanlRRuae9XCpb/j5bDCbPPMOBfCWhnl/7EDJz0jEMCi/RhccCE8r1+Q=="],
 
     "@bcoe/v8-coverage": ["@bcoe/v8-coverage@1.0.2", "", {}, "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA=="],
 
-    "@better-auth/stripe": ["@better-auth/stripe@1.2.9", "", { "dependencies": { "better-auth": "^1.2.9", "zod": "^3.24.1" } }, "sha512-p7Q3rX63UBE+KMlRTGHeytp13/g8fQU5w8wcY6FPubsGEAPoZl7ymcqKu3AAxpFTaWOGHPVov+4no7uNGl6Qug=="],
+    "@better-auth/stripe": ["@better-auth/stripe@1.2.10", "", { "dependencies": { "better-auth": "^1.2.10", "zod": "^3.24.1" } }, "sha512-ZWPJNICiT1xaWHnmVswGLVsVik60dmlozsJv71dBGWd5ua3Cdz74r+OCaCvbalGyVn1nZPBPaGvCCd71U5Tliw=="],
 
     "@better-auth/utils": ["@better-auth/utils@0.2.5", "", { "dependencies": { "typescript": "^5.8.2", "uncrypto": "^0.1.3" } }, "sha512-uI2+/8h/zVsH8RrYdG8eUErbuGBk16rZKQfz8CjxQOyCE6v7BqFYEbFwvOkvl1KbUdxhqOnXp78+uE5h8qVEgQ=="],
 
@@ -426,7 +429,7 @@
 
     "@browserbasehq/sdk": ["@browserbasehq/sdk@2.6.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-83iXP5D7xMm8Wyn66TUaUrgoByCmAJuoMoZQI3sGg3JAiMlTfnCIMqyVBoNSaItaPIkaCnrsj6LiusmXV2X9YA=="],
 
-    "@browserbasehq/stagehand": ["@browserbasehq/stagehand@2.2.1", "", { "dependencies": { "@anthropic-ai/sdk": "0.39.0", "@browserbasehq/sdk": "^2.4.0", "@google/genai": "^0.8.0", "ai": "^4.3.9", "openai": "^4.87.1", "pino": "^9.6.0", "pino-pretty": "^13.0.0", "playwright": "^1.52.0", "ws": "^8.18.0", "zod-to-json-schema": "^3.23.5" }, "optionalDependencies": { "@ai-sdk/anthropic": "^1.2.6", "@ai-sdk/azure": "^1.3.19", "@ai-sdk/cerebras": "^0.2.6", "@ai-sdk/deepseek": "^0.2.13", "@ai-sdk/google": "^1.2.6", "@ai-sdk/groq": "^1.2.4", "@ai-sdk/mistral": "^1.2.7", "@ai-sdk/openai": "^1.0.14", "@ai-sdk/perplexity": "^1.1.7", "@ai-sdk/togetherai": "^0.2.6", "@ai-sdk/xai": "^1.2.15", "ollama-ai-provider": "^1.2.0" }, "peerDependencies": { "@playwright/test": "^1.42.1", "deepmerge": "^4.3.1", "dotenv": "^16.4.5", "zod": "^3.23.8" } }, "sha512-RwxhvlXKdEVf8cQpHnA05pj+PA92lGLCA1bkqZwri2GDzWWiDx7WTVf0QPWfAD6T8E3cD4hVHIVQpbCmogwxFg=="],
+    "@browserbasehq/stagehand": ["@browserbasehq/stagehand@2.3.1", "", { "dependencies": { "@anthropic-ai/sdk": "0.39.0", "@browserbasehq/sdk": "^2.4.0", "@google/genai": "^0.8.0", "ai": "^4.3.9", "devtools-protocol": "^0.0.1464554", "fetch-cookie": "^3.1.0", "openai": "^4.87.1", "pino": "^9.6.0", "pino-pretty": "^13.0.0", "playwright": "^1.52.0", "ws": "^8.18.0", "zod-to-json-schema": "^3.23.5" }, "optionalDependencies": { "@ai-sdk/anthropic": "^1.2.6", "@ai-sdk/azure": "^1.3.19", "@ai-sdk/cerebras": "^0.2.6", "@ai-sdk/deepseek": "^0.2.13", "@ai-sdk/google": "^1.2.6", "@ai-sdk/groq": "^1.2.4", "@ai-sdk/mistral": "^1.2.7", "@ai-sdk/openai": "^1.0.14", "@ai-sdk/perplexity": "^1.1.7", "@ai-sdk/togetherai": "^0.2.6", "@ai-sdk/xai": "^1.2.15", "ollama-ai-provider": "^1.2.0" }, "peerDependencies": { "@playwright/test": "^1.42.1", "deepmerge": "^4.3.1", "dotenv": "^16.4.5", "zod": "^3.23.8" } }, "sha512-fEsnBE8cj7oyb6wYEnU1d38zuQs4LmPWmjnsYbnXY1B3c/wD7e0uzxO72lKeN98P1bA26k3T6ayD8OwRq2LGuw=="],
 
     "@cerebras/cerebras_cloud_sdk": ["@cerebras/cerebras_cloud_sdk@1.35.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-bQ6KYHmcvudHJ1aLzqkeETn3Y071/8/zpcZho6g4pKZ+VluHvLmIG0buhrwF9qJY5WSLmXR/s4pruxVRmfV7yQ=="],
 
@@ -568,6 +571,10 @@
 
     "@ioredis/commands": ["@ioredis/commands@1.2.0", "", {}, "sha512-Sx1pU8EM64o2BrqNpEO1CNLtKQwyhuXuqyfH7oGKCk+1a33d2r5saW8zNwm3j6BTExtjrv2BxTgzzkMwts6vGg=="],
 
+    "@isaacs/balanced-match": ["@isaacs/balanced-match@4.0.1", "", {}, "sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ=="],
+
+    "@isaacs/brace-expansion": ["@isaacs/brace-expansion@5.0.0", "", { "dependencies": { "@isaacs/balanced-match": "^4.0.1" } }, "sha512-ZT55BDLV0yv0RBm2czMiZ+SqCGO7AvmOM3G/w2xhVPH+te0aKgFjmBvGlL1dH+ql2tgGO3MVrbb3jCKyvpgnxA=="],
+
     "@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="],
 
     "@isaacs/fs-minipass": ["@isaacs/fs-minipass@4.0.1", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="],
@@ -596,25 +603,25 @@
 
     "@mdx-js/mdx": ["@mdx-js/mdx@3.1.0", "", { "dependencies": { "@types/estree": "^1.0.0", "@types/estree-jsx": "^1.0.0", "@types/hast": "^3.0.0", "@types/mdx": "^2.0.0", "collapse-white-space": "^2.0.0", "devlop": "^1.0.0", "estree-util-is-identifier-name": "^3.0.0", "estree-util-scope": "^1.0.0", "estree-walker": "^3.0.0", "hast-util-to-jsx-runtime": "^2.0.0", "markdown-extensions": "^2.0.0", "recma-build-jsx": "^1.0.0", "recma-jsx": "^1.0.0", "recma-stringify": "^1.0.0", "rehype-recma": "^1.0.0", "remark-mdx": "^3.0.0", "remark-parse": "^11.0.0", "remark-rehype": "^11.0.0", "source-map": "^0.7.0", "unified": "^11.0.0", "unist-util-position-from-estree": "^2.0.0", "unist-util-stringify-position": "^4.0.0", "unist-util-visit": "^5.0.0", "vfile": "^6.0.0" } }, "sha512-/QxEhPAvGwbQmy1Px8F899L5Uc2KZ6JtXwlCgJmjSTBedwOZkByYcBG4GceIGPXRDsmfxhHazuS+hlOShRLeDw=="],
 
-    "@next/env": ["@next/env@15.3.3", "", {}, "sha512-OdiMrzCl2Xi0VTjiQQUK0Xh7bJHnOuET2s+3V+Y40WJBAXrJeGA3f+I8MZJ/YQ3mVGi5XGR1L66oFlgqXhQ4Vw=="],
+    "@next/env": ["@next/env@15.3.4", "", {}, "sha512-ZkdYzBseS6UjYzz6ylVKPOK+//zLWvD6Ta+vpoye8cW11AjiQjGYVibF0xuvT4L0iJfAPfZLFidaEzAOywyOAQ=="],
 
-    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@15.3.3", "", { "os": "darwin", "cpu": "arm64" }, "sha512-WRJERLuH+O3oYB4yZNVahSVFmtxRNjNF1I1c34tYMoJb0Pve+7/RaLAJJizyYiFhjYNGHRAE1Ri2Fd23zgDqhg=="],
+    "@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@15.3.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-z0qIYTONmPRbwHWvpyrFXJd5F9YWLCsw3Sjrzj2ZvMYy9NPQMPZ1NjOJh4ojr4oQzcGYwgJKfidzehaNa1BpEg=="],
 
-    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@15.3.3", "", { "os": "darwin", "cpu": "x64" }, "sha512-XHdzH/yBc55lu78k/XwtuFR/ZXUTcflpRXcsu0nKmF45U96jt1tsOZhVrn5YH+paw66zOANpOnFQ9i6/j+UYvw=="],
+    "@next/swc-darwin-x64": ["@next/swc-darwin-x64@15.3.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-Z0FYJM8lritw5Wq+vpHYuCIzIlEMjewG2aRkc3Hi2rcbULknYL/xqfpBL23jQnCSrDUGAo/AEv0Z+s2bff9Zkw=="],
 
-    "@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@15.3.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-VZ3sYL2LXB8znNGcjhocikEkag/8xiLgnvQts41tq6i+wql63SMS1Q6N8RVXHw5pEUjiof+II3HkDd7GFcgkzw=="],
+    "@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@15.3.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-l8ZQOCCg7adwmsnFm8m5q9eIPAHdaB2F3cxhufYtVo84pymwKuWfpYTKcUiFcutJdp9xGHC+F1Uq3xnFU1B/7g=="],
 
-    "@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@15.3.3", "", { "os": "linux", "cpu": "arm64" }, "sha512-h6Y1fLU4RWAp1HPNJWDYBQ+e3G7sLckyBXhmH9ajn8l/RSMnhbuPBV/fXmy3muMcVwoJdHL+UtzRzs0nXOf9SA=="],
+    "@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@15.3.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-wFyZ7X470YJQtpKot4xCY3gpdn8lE9nTlldG07/kJYexCUpX1piX+MBfZdvulo+t1yADFVEuzFfVHfklfEx8kw=="],
 
-    "@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@15.3.3", "", { "os": "linux", "cpu": "x64" }, "sha512-jJ8HRiF3N8Zw6hGlytCj5BiHyG/K+fnTKVDEKvUCyiQ/0r5tgwO7OgaRiOjjRoIx2vwLR+Rz8hQoPrnmFbJdfw=="],
+    "@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@15.3.4", "", { "os": "linux", "cpu": "x64" }, "sha512-gEbH9rv9o7I12qPyvZNVTyP/PWKqOp8clvnoYZQiX800KkqsaJZuOXkWgMa7ANCCh/oEN2ZQheh3yH8/kWPSEg=="],
 
-    "@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@15.3.3", "", { "os": "linux", "cpu": "x64" }, "sha512-HrUcTr4N+RgiiGn3jjeT6Oo208UT/7BuTr7K0mdKRBtTbT4v9zJqCDKO97DUqqoBK1qyzP1RwvrWTvU6EPh/Cw=="],
+    "@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@15.3.4", "", { "os": "linux", "cpu": "x64" }, "sha512-Cf8sr0ufuC/nu/yQ76AnarbSAXcwG/wj+1xFPNbyNo8ltA6kw5d5YqO8kQuwVIxk13SBdtgXrNyom3ZosHAy4A=="],
 
-    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@15.3.3", "", { "os": "win32", "cpu": "arm64" }, "sha512-SxorONgi6K7ZUysMtRF3mIeHC5aA3IQLmKFQzU0OuhuUYwpOBc1ypaLJLP5Bf3M9k53KUUUj4vTPwzGvl/NwlQ=="],
+    "@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@15.3.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-ay5+qADDN3rwRbRpEhTOreOn1OyJIXS60tg9WMYTWCy3fB6rGoyjLVxc4dR9PYjEdR2iDYsaF5h03NA+XuYPQQ=="],
 
-    "@next/swc-win32-ia32-msvc": ["@next/swc-win32-ia32-msvc@14.2.29", "", { "os": "win32", "cpu": "ia32" }, "sha512-vkcriFROT4wsTdSeIzbxaZjTNTFKjSYmLd8q/GVH3Dn8JmYjUKOuKXHK8n+lovW/kdcpIvydO5GtN+It2CvKWA=="],
+    "@next/swc-win32-ia32-msvc": ["@next/swc-win32-ia32-msvc@14.2.30", "", { "os": "win32", "cpu": "ia32" }, "sha512-pVZMnFok5qEX4RT59mK2hEVtJX+XFfak+/rjHpyFh7juiT52r177bfFKhnlafm0UOSldhXjj32b+LZIOdswGTg=="],
 
-    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@15.3.3", "", { "os": "win32", "cpu": "x64" }, "sha512-4QZG6F8enl9/S2+yIiOiju0iCTFd93d8VC1q9LZS4p/Xuk81W2QDjCFeoogmrWWkAD59z8ZxepBQap2dKS5ruw=="],
+    "@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@15.3.4", "", { "os": "win32", "cpu": "x64" }, "sha512-4kDt31Bc9DGyYs41FTL1/kNpDeHyha2TC0j5sRRoKCyrhNcfZ/nRQkAUlF27mETwm8QyHqIjHJitfcza2Iykfg=="],
 
     "@noble/ciphers": ["@noble/ciphers@0.6.0", "", {}, "sha512-mIbq/R9QXk5/cTfESb1OKtyFnk7oc1Om/8onA1158K9/OZUQFDEVy55jVTato+xmp3XX6F6Qh0zz0Nc1AxAlRQ=="],
 
@@ -758,7 +765,7 @@
 
     "@pkgjs/parseargs": ["@pkgjs/parseargs@0.11.0", "", {}, "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg=="],
 
-    "@playwright/test": ["@playwright/test@1.52.0", "", { "dependencies": { "playwright": "1.52.0" }, "bin": { "playwright": "cli.js" } }, "sha512-uh6W7sb55hl7D6vsAeA+V2p5JnlAqzhqFyF0VcJkKZXkgnFcVG9PziERRHQfPLfNGx1C292a4JqbWzhR8L4R1g=="],
+    "@playwright/test": ["@playwright/test@1.53.1", "", { "dependencies": { "playwright": "1.53.1" }, "bin": { "playwright": "cli.js" } }, "sha512-Z4c23LHV0muZ8hfv4jw6HngPJkbbtZxTkxPNIg7cJcTc9C28N/p2q7g3JZS2SiKBBHJ3uM1dgDye66bB7LEk5w=="],
 
     "@prisma/instrumentation": ["@prisma/instrumentation@6.8.2", "", { "dependencies": { "@opentelemetry/instrumentation": "^0.52.0 || ^0.53.0 || ^0.54.0 || ^0.55.0 || ^0.56.0 || ^0.57.0" }, "peerDependencies": { "@opentelemetry/api": "^1.8" } }, "sha512-5NCTbZjw7a+WIZ/ey6G8SY+YKcyM2zBF0hOT1muvqC9TbVtTCr5Qv3RL/2iNDOzLUHEvo4I1uEfioyfuNOGK8Q=="],
 
@@ -936,11 +943,11 @@
 
     "@resvg/resvg-wasm": ["@resvg/resvg-wasm@2.4.0", "", {}, "sha512-C7c51Nn4yTxXFKvgh2txJFNweaVcfUPQxwEUFw4aWsCmfiBDJsTSwviIF8EcwjQ6k8bPyMWCl1vw4BdxE569Cg=="],
 
-    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.9", "", {}, "sha512-e9MeMtVWo186sgvFFJOPGy7/d2j2mZhLJIdVW0C/xDluuOvymEATqz6zKsP0ZmXGzQtqlyjz5sC1sYQUoJG98w=="],
+    "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.0-beta.11", "", {}, "sha512-L/gAA/hyCSuzTF1ftlzUSI/IKr2POHsv1Dd78GfqkR83KMNuswWD61JxGV2L7nRwBBBSDr6R1gCkdTmoN7W4ag=="],
 
     "@rollup/plugin-commonjs": ["@rollup/plugin-commonjs@28.0.1", "", { "dependencies": { "@rollup/pluginutils": "^5.0.1", "commondir": "^1.0.1", "estree-walker": "^2.0.2", "fdir": "^6.2.0", "is-reference": "1.2.1", "magic-string": "^0.30.3", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^2.68.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-+tNWdlWKbpB3WgBN7ijjYkq9X5uhjmcvyjEght4NmH5fAU++zfQzAJ6wumLS+dNcvwEZhKx2Z+skY8m7v0wGSA=="],
 
-    "@rollup/pluginutils": ["@rollup/pluginutils@5.1.4", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ=="],
+    "@rollup/pluginutils": ["@rollup/pluginutils@5.2.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-qWJ2ZTbmumwiLFomfzTyt5Kng4hwPi9rwCYN4SHb6eaRU1KNO4ccxINHr/VhH4GgPlt1XfSTLX2LBTme8ne4Zw=="],
 
     "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.35.0", "", { "os": "android", "cpu": "arm" }, "sha512-uYQ2WfPaqz5QtVgMxfN6NpLD+no0MYHDBywl7itPYd3K5TjjSghNKmX8ic9S8NU8w81NVhJv/XojcHptRly7qQ=="],
 
@@ -982,17 +989,17 @@
 
     "@selderee/plugin-htmlparser2": ["@selderee/plugin-htmlparser2@0.11.0", "", { "dependencies": { "domhandler": "^5.0.3", "selderee": "^0.11.0" } }, "sha512-P33hHGdldxGabLFjPPpaTxVolMrzrcegejx+0GxjrIb9Zv48D8yAIA/QTDR2dFl7Uz7urX8aX6+5bCZslr+gWQ=="],
 
-    "@sentry-internal/browser-utils": ["@sentry-internal/browser-utils@9.24.0", "", { "dependencies": { "@sentry/core": "9.24.0" } }, "sha512-fWIrHyui8KKufnbqhGyDvvr+u9wiOEEzxXEjs/CKp+6fa+jej6Mk8K+su1f/mz7R3HVzhxvht/gZ+y193uK4qw=="],
+    "@sentry-internal/browser-utils": ["@sentry-internal/browser-utils@9.30.0", "", { "dependencies": { "@sentry/core": "9.30.0" } }, "sha512-e6ZlN8oWheCB0YJSGlBNUlh6UPnY5Ecj1P+/cgeKBhNm7c3bIx4J50485hB8LQsu+b7Q11L2o/wucZ//Pb6FCg=="],
 
-    "@sentry-internal/feedback": ["@sentry-internal/feedback@9.24.0", "", { "dependencies": { "@sentry/core": "9.24.0" } }, "sha512-Z9jQqKzRppwAEqiytLWNV8JOo52vlxcSGz52FjKx3KXG75PXwk0M3sBXh762WoGLisUIRLTp8LOk6304L/O8dg=="],
+    "@sentry-internal/feedback": ["@sentry-internal/feedback@9.30.0", "", { "dependencies": { "@sentry/core": "9.30.0" } }, "sha512-qAZ7xxLqZM7GlEvmSUmTHnoueg+fc7esMQD4vH8pS7HI3n9C5MjGn3HHlndRpD8lL7iUUQ0TPZQgU6McbzMDyw=="],
 
-    "@sentry-internal/replay": ["@sentry-internal/replay@9.24.0", "", { "dependencies": { "@sentry-internal/browser-utils": "9.24.0", "@sentry/core": "9.24.0" } }, "sha512-312wMPeQI8K2vO/lA/CF6Uv5UReoZC7RarsNUJEoOKa9Bq1BXWUq929oTHzu/2NDv194H2u3eqSGsSp6xiuKTw=="],
+    "@sentry-internal/replay": ["@sentry-internal/replay@9.30.0", "", { "dependencies": { "@sentry-internal/browser-utils": "9.30.0", "@sentry/core": "9.30.0" } }, "sha512-+6wkqQGLJuFUzvGRzbh3iIhFGyxQx/Oxc0ODDKmz9ag2xYRjCYb3UUQXmQX9navAF0HXUsq8ajoJPm2L1ZyWVg=="],
 
-    "@sentry-internal/replay-canvas": ["@sentry-internal/replay-canvas@9.24.0", "", { "dependencies": { "@sentry-internal/replay": "9.24.0", "@sentry/core": "9.24.0" } }, "sha512-506RdDF6iE8hMyzpzp9Vc0GM7kELxxs7UCoi/6KpvXFftcydWI3S2bru8dEZsxVoKh2hdle6SpbNgl+iPI0DSQ=="],
+    "@sentry-internal/replay-canvas": ["@sentry-internal/replay-canvas@9.30.0", "", { "dependencies": { "@sentry-internal/replay": "9.30.0", "@sentry/core": "9.30.0" } }, "sha512-I4MxS27rfV7vnOU29L80y4baZ4I1XqpnYvC/yLN7C17nA8eDCufQ8WVomli41y8JETnfcxlm68z7CS0sO4RCSA=="],
 
     "@sentry/babel-plugin-component-annotate": ["@sentry/babel-plugin-component-annotate@3.5.0", "", {}, "sha512-s2go8w03CDHbF9luFGtBHKJp4cSpsQzNVqgIa9Pfa4wnjipvrK6CxVT4icpLA3YO6kg5u622Yoa5GF3cJdippw=="],
 
-    "@sentry/browser": ["@sentry/browser@9.24.0", "", { "dependencies": { "@sentry-internal/browser-utils": "9.24.0", "@sentry-internal/feedback": "9.24.0", "@sentry-internal/replay": "9.24.0", "@sentry-internal/replay-canvas": "9.24.0", "@sentry/core": "9.24.0" } }, "sha512-RP+27/owvIqD4J0TibIHK1UcA7iObxLOXBEilDKjaJOZMLhv3JkpU8A+UI9pFzEYqeIGVDDaBzYgbCHrLWcoCA=="],
+    "@sentry/browser": ["@sentry/browser@9.30.0", "", { "dependencies": { "@sentry-internal/browser-utils": "9.30.0", "@sentry-internal/feedback": "9.30.0", "@sentry-internal/replay": "9.30.0", "@sentry-internal/replay-canvas": "9.30.0", "@sentry/core": "9.30.0" } }, "sha512-sRyW6A9nIieTTI26MYXk1DmWEhmphTjZevusNWla+vvUigCmSjuH+xZw19w43OyvF3bu261Skypnm/mAalOTwg=="],
 
     "@sentry/bundler-plugin-core": ["@sentry/bundler-plugin-core@3.5.0", "", { "dependencies": { "@babel/core": "^7.18.5", "@sentry/babel-plugin-component-annotate": "3.5.0", "@sentry/cli": "2.42.2", "dotenv": "^16.3.1", "find-up": "^5.0.0", "glob": "^9.3.2", "magic-string": "0.30.8", "unplugin": "1.0.1" } }, "sha512-zDzPrhJqAAy2VzV4g540qAZH4qxzisstK2+NIJPZUUKztWRWUV2cMHsyUtdctYgloGkLyGpZJBE3RE6dmP/xqQ=="],
 
@@ -1012,35 +1019,35 @@
 
     "@sentry/cli-win32-x64": ["@sentry/cli-win32-x64@2.42.2", "", { "os": "win32", "cpu": "x64" }, "sha512-vPPGHjYoaGmfrU7xhfFxG7qlTBacroz5NdT+0FmDn6692D8IvpNXl1K+eV3Kag44ipJBBeR8g1HRJyx/F/9ACw=="],
 
-    "@sentry/core": ["@sentry/core@9.24.0", "", {}, "sha512-uRWrB4Y49ZOWcDLCXqdjd2Fs6Onill0GQI+JgXMw7wa+i03+QRiQvUAUyde8O62jR4dvP3GDo9PDWnDNhi3z5A=="],
+    "@sentry/core": ["@sentry/core@9.30.0", "", {}, "sha512-JfEpeQ8a1qVJEb9DxpFTFy1J1gkNdlgKAPiqYGNnm4yQbnfl2Kb/iEo1if70FkiHc52H8fJwISEF90pzMm6lPg=="],
 
-    "@sentry/nextjs": ["@sentry/nextjs@9.24.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/semantic-conventions": "^1.34.0", "@rollup/plugin-commonjs": "28.0.1", "@sentry-internal/browser-utils": "9.24.0", "@sentry/core": "9.24.0", "@sentry/node": "9.24.0", "@sentry/opentelemetry": "9.24.0", "@sentry/react": "9.24.0", "@sentry/vercel-edge": "9.24.0", "@sentry/webpack-plugin": "3.5.0", "chalk": "3.0.0", "resolve": "1.22.8", "rollup": "4.35.0", "stacktrace-parser": "^0.1.10" }, "peerDependencies": { "next": "^13.2.0 || ^14.0 || ^15.0.0-rc.0" } }, "sha512-KDZ2EX2otbkaVnp6rBADdhSUrsg6r+KWeeZbYVW7zBYZ99ORG7+m3pOtf7qaMcoSivhElPoLzblCyvK0zcPpTg=="],
+    "@sentry/nextjs": ["@sentry/nextjs@9.30.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/semantic-conventions": "^1.34.0", "@rollup/plugin-commonjs": "28.0.1", "@sentry-internal/browser-utils": "9.30.0", "@sentry/core": "9.30.0", "@sentry/node": "9.30.0", "@sentry/opentelemetry": "9.30.0", "@sentry/react": "9.30.0", "@sentry/vercel-edge": "9.30.0", "@sentry/webpack-plugin": "3.5.0", "chalk": "3.0.0", "resolve": "1.22.8", "rollup": "4.35.0", "stacktrace-parser": "^0.1.10" }, "peerDependencies": { "next": "^13.2.0 || ^14.0 || ^15.0.0-rc.0" } }, "sha512-9Ouf0Tng1HAPeYPaT9xUSj6jt/qV+h9/6Vf2yzIEGR4j1FbP5wdccGMs8LRdkp9msqEwv2ERnU////zHL1fpyA=="],
 
-    "@sentry/node": ["@sentry/node@9.24.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/context-async-hooks": "^1.30.1", "@opentelemetry/core": "^1.30.1", "@opentelemetry/instrumentation": "^0.57.2", "@opentelemetry/instrumentation-amqplib": "^0.46.1", "@opentelemetry/instrumentation-connect": "0.43.1", "@opentelemetry/instrumentation-dataloader": "0.16.1", "@opentelemetry/instrumentation-express": "0.47.1", "@opentelemetry/instrumentation-fs": "0.19.1", "@opentelemetry/instrumentation-generic-pool": "0.43.1", "@opentelemetry/instrumentation-graphql": "0.47.1", "@opentelemetry/instrumentation-hapi": "0.45.2", "@opentelemetry/instrumentation-http": "0.57.2", "@opentelemetry/instrumentation-ioredis": "0.47.1", "@opentelemetry/instrumentation-kafkajs": "0.7.1", "@opentelemetry/instrumentation-knex": "0.44.1", "@opentelemetry/instrumentation-koa": "0.47.1", "@opentelemetry/instrumentation-lru-memoizer": "0.44.1", "@opentelemetry/instrumentation-mongodb": "0.52.0", "@opentelemetry/instrumentation-mongoose": "0.46.1", "@opentelemetry/instrumentation-mysql": "0.45.1", "@opentelemetry/instrumentation-mysql2": "0.45.2", "@opentelemetry/instrumentation-pg": "0.51.1", "@opentelemetry/instrumentation-redis-4": "0.46.1", "@opentelemetry/instrumentation-tedious": "0.18.1", "@opentelemetry/instrumentation-undici": "0.10.1", "@opentelemetry/resources": "^1.30.1", "@opentelemetry/sdk-trace-base": "^1.30.1", "@opentelemetry/semantic-conventions": "^1.34.0", "@prisma/instrumentation": "6.8.2", "@sentry/core": "9.24.0", "@sentry/opentelemetry": "9.24.0", "import-in-the-middle": "^1.13.1", "minimatch": "^9.0.0" } }, "sha512-rIe8rLCdPi/9VWkoRlXRCbjpNlKhHeS8EqlT40ZwlWxdJl5WOcktq3mIWcV2oTqupWogDImjQgeCeydXWt5aog=="],
+    "@sentry/node": ["@sentry/node@9.30.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/context-async-hooks": "^1.30.1", "@opentelemetry/core": "^1.30.1", "@opentelemetry/instrumentation": "^0.57.2", "@opentelemetry/instrumentation-amqplib": "^0.46.1", "@opentelemetry/instrumentation-connect": "0.43.1", "@opentelemetry/instrumentation-dataloader": "0.16.1", "@opentelemetry/instrumentation-express": "0.47.1", "@opentelemetry/instrumentation-fs": "0.19.1", "@opentelemetry/instrumentation-generic-pool": "0.43.1", "@opentelemetry/instrumentation-graphql": "0.47.1", "@opentelemetry/instrumentation-hapi": "0.45.2", "@opentelemetry/instrumentation-http": "0.57.2", "@opentelemetry/instrumentation-ioredis": "0.47.1", "@opentelemetry/instrumentation-kafkajs": "0.7.1", "@opentelemetry/instrumentation-knex": "0.44.1", "@opentelemetry/instrumentation-koa": "0.47.1", "@opentelemetry/instrumentation-lru-memoizer": "0.44.1", "@opentelemetry/instrumentation-mongodb": "0.52.0", "@opentelemetry/instrumentation-mongoose": "0.46.1", "@opentelemetry/instrumentation-mysql": "0.45.1", "@opentelemetry/instrumentation-mysql2": "0.45.2", "@opentelemetry/instrumentation-pg": "0.51.1", "@opentelemetry/instrumentation-redis-4": "0.46.1", "@opentelemetry/instrumentation-tedious": "0.18.1", "@opentelemetry/instrumentation-undici": "0.10.1", "@opentelemetry/resources": "^1.30.1", "@opentelemetry/sdk-trace-base": "^1.30.1", "@opentelemetry/semantic-conventions": "^1.34.0", "@prisma/instrumentation": "6.8.2", "@sentry/core": "9.30.0", "@sentry/opentelemetry": "9.30.0", "import-in-the-middle": "^1.13.1", "minimatch": "^9.0.0" } }, "sha512-jHuSSKro2DUaccGcYSBbB8Rj0sG+LRh1iSWrJ+4c4Pj7tJFN9MbeMybC1buMSzAp+rwHUMZ3+ws0kgNVtsRJJg=="],
 
-    "@sentry/opentelemetry": ["@sentry/opentelemetry@9.24.0", "", { "dependencies": { "@sentry/core": "9.24.0" }, "peerDependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/context-async-hooks": "^1.30.1 || ^2.0.0", "@opentelemetry/core": "^1.30.1 || ^2.0.0", "@opentelemetry/instrumentation": "^0.57.1 || ^0.200.0", "@opentelemetry/sdk-trace-base": "^1.30.1 || ^2.0.0", "@opentelemetry/semantic-conventions": "^1.34.0" } }, "sha512-bdXXwBLuIS127CjMveizBbgBKQEGlL3Ye8LxHCKqvifNK9BXgXGPnh6bHum/EgskWqx4ni/aET1h4f1kluql5A=="],
+    "@sentry/opentelemetry": ["@sentry/opentelemetry@9.30.0", "", { "dependencies": { "@sentry/core": "9.30.0" }, "peerDependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/context-async-hooks": "^1.30.1 || ^2.0.0", "@opentelemetry/core": "^1.30.1 || ^2.0.0", "@opentelemetry/instrumentation": "^0.57.1 || ^0.200.0", "@opentelemetry/sdk-trace-base": "^1.30.1 || ^2.0.0", "@opentelemetry/semantic-conventions": "^1.34.0" } }, "sha512-LhTmyGGLAP/LAxs/oXuPs0LC5Z80QSLL1oUoBRB5/+MitK7Huug6n8ZFjPTP3/6bT67XOVqILCdj8BwMlBeXhA=="],
 
-    "@sentry/react": ["@sentry/react@9.24.0", "", { "dependencies": { "@sentry/browser": "9.24.0", "@sentry/core": "9.24.0", "hoist-non-react-statics": "^3.3.2" }, "peerDependencies": { "react": "^16.14.0 || 17.x || 18.x || 19.x" } }, "sha512-CEgNuxnaax5JXvCJGO8MaPU6Doqf8OMK/52SwZxTwJJFsQBAC2v7Dl+Qot7H4GVb0exg3psumL4NjNeXAfGcpA=="],
+    "@sentry/react": ["@sentry/react@9.30.0", "", { "dependencies": { "@sentry/browser": "9.30.0", "@sentry/core": "9.30.0", "hoist-non-react-statics": "^3.3.2" }, "peerDependencies": { "react": "^16.14.0 || 17.x || 18.x || 19.x" } }, "sha512-asA49AkZ/g9CCeW0eA0Ent0DF60S4k2IHxbu+Q1mqgbRRmbn859oL2Bgsu/EvzWf5edeQtuUml8LIo4YoFwfMA=="],
 
-    "@sentry/vercel-edge": ["@sentry/vercel-edge@9.24.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@sentry/core": "9.24.0" } }, "sha512-X85EkcrHoICRDQ5+6f5KqGhXATbFaTw/NEz92uVqSLQjv0EEKJ+SPwQpIH9ccLSeXg/R5GYXR0Z6kEYS/zo/Vw=="],
+    "@sentry/vercel-edge": ["@sentry/vercel-edge@9.30.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@sentry/core": "9.30.0" } }, "sha512-zhxXEXQbf1ggyyR6pf/ZED8cj5Ubb2iObnpZaGHNWRccsToq7EecW0LKUJjdWKqDSqlv1DaI5yUAmn4oheQ4zQ=="],
 
     "@sentry/webpack-plugin": ["@sentry/webpack-plugin@3.5.0", "", { "dependencies": { "@sentry/bundler-plugin-core": "3.5.0", "unplugin": "1.0.1", "uuid": "^9.0.0" }, "peerDependencies": { "webpack": ">=4.40.0" } }, "sha512-xvclj0QY2HyU7uJLzOlHSrZQBDwfnGKJxp8mmlU4L7CwmK+8xMCqlO7tYZoqE4K/wU3c2xpXql70x8qmvNMxzQ=="],
 
-    "@shikijs/core": ["@shikijs/core@3.4.2", "", { "dependencies": { "@shikijs/types": "3.4.2", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4", "hast-util-to-html": "^9.0.5" } }, "sha512-AG8vnSi1W2pbgR2B911EfGqtLE9c4hQBYkv/x7Z+Kt0VxhgQKcW7UNDVYsu9YxwV6u+OJrvdJrMq6DNWoBjihQ=="],
+    "@shikijs/core": ["@shikijs/core@3.7.0", "", { "dependencies": { "@shikijs/types": "3.7.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4", "hast-util-to-html": "^9.0.5" } }, "sha512-yilc0S9HvTPyahHpcum8eonYrQtmGTU0lbtwxhA6jHv4Bm1cAdlPFRCJX4AHebkCm75aKTjjRAW+DezqD1b/cg=="],
 
-    "@shikijs/engine-javascript": ["@shikijs/engine-javascript@3.4.2", "", { "dependencies": { "@shikijs/types": "3.4.2", "@shikijs/vscode-textmate": "^10.0.2", "oniguruma-to-es": "^4.3.3" } }, "sha512-1/adJbSMBOkpScCE/SB6XkjJU17ANln3Wky7lOmrnpl+zBdQ1qXUJg2GXTYVHRq+2j3hd1DesmElTXYDgtfSOQ=="],
+    "@shikijs/engine-javascript": ["@shikijs/engine-javascript@3.7.0", "", { "dependencies": { "@shikijs/types": "3.7.0", "@shikijs/vscode-textmate": "^10.0.2", "oniguruma-to-es": "^4.3.3" } }, "sha512-0t17s03Cbv+ZcUvv+y33GtX75WBLQELgNdVghnsdhTgU3hVcWcMsoP6Lb0nDTl95ZJfbP1mVMO0p3byVh3uuzA=="],
 
-    "@shikijs/engine-oniguruma": ["@shikijs/engine-oniguruma@3.4.2", "", { "dependencies": { "@shikijs/types": "3.4.2", "@shikijs/vscode-textmate": "^10.0.2" } }, "sha512-zcZKMnNndgRa3ORja6Iemsr3DrLtkX3cAF7lTJkdMB6v9alhlBsX9uNiCpqofNrXOvpA3h6lHcLJxgCIhVOU5Q=="],
+    "@shikijs/engine-oniguruma": ["@shikijs/engine-oniguruma@3.7.0", "", { "dependencies": { "@shikijs/types": "3.7.0", "@shikijs/vscode-textmate": "^10.0.2" } }, "sha512-5BxcD6LjVWsGu4xyaBC5bu8LdNgPCVBnAkWTtOCs/CZxcB22L8rcoWfv7Hh/3WooVjBZmFtyxhgvkQFedPGnFw=="],
 
-    "@shikijs/langs": ["@shikijs/langs@3.4.2", "", { "dependencies": { "@shikijs/types": "3.4.2" } }, "sha512-H6azIAM+OXD98yztIfs/KH5H4PU39t+SREhmM8LaNXyUrqj2mx+zVkr8MWYqjceSjDw9I1jawm1WdFqU806rMA=="],
+    "@shikijs/langs": ["@shikijs/langs@3.7.0", "", { "dependencies": { "@shikijs/types": "3.7.0" } }, "sha512-1zYtdfXLr9xDKLTGy5kb7O0zDQsxXiIsw1iIBcNOO8Yi5/Y1qDbJ+0VsFoqTlzdmneO8Ij35g7QKF8kcLyznCQ=="],
 
-    "@shikijs/rehype": ["@shikijs/rehype@3.4.2", "", { "dependencies": { "@shikijs/types": "3.4.2", "@types/hast": "^3.0.4", "hast-util-to-string": "^3.0.1", "shiki": "3.4.2", "unified": "^11.0.5", "unist-util-visit": "^5.0.0" } }, "sha512-atbsrT3UKs25OdKVbNoHyKO9ZP7KEBPlo1oanPGMkvUL0fLictpxMPz6vPE2YTeHhpwz7EMrA4K4FHRY8XAReg=="],
+    "@shikijs/rehype": ["@shikijs/rehype@3.7.0", "", { "dependencies": { "@shikijs/types": "3.7.0", "@types/hast": "^3.0.4", "hast-util-to-string": "^3.0.1", "shiki": "3.7.0", "unified": "^11.0.5", "unist-util-visit": "^5.0.0" } }, "sha512-YjAZxhQnBXE8ehppKGzuVGPoE4pjVsxqzkWhBZlkP495AjlR++MgfiRFcQfDt3qX5lK3gEDTcghB/8E3yNrWqQ=="],
 
-    "@shikijs/themes": ["@shikijs/themes@3.4.2", "", { "dependencies": { "@shikijs/types": "3.4.2" } }, "sha512-qAEuAQh+brd8Jyej2UDDf+b4V2g1Rm8aBIdvt32XhDPrHvDkEnpb7Kzc9hSuHUxz0Iuflmq7elaDuQAP9bHIhg=="],
+    "@shikijs/themes": ["@shikijs/themes@3.7.0", "", { "dependencies": { "@shikijs/types": "3.7.0" } }, "sha512-VJx8497iZPy5zLiiCTSIaOChIcKQwR0FebwE9S3rcN0+J/GTWwQ1v/bqhTbpbY3zybPKeO8wdammqkpXc4NVjQ=="],
 
-    "@shikijs/transformers": ["@shikijs/transformers@3.4.2", "", { "dependencies": { "@shikijs/core": "3.4.2", "@shikijs/types": "3.4.2" } }, "sha512-I5baLVi/ynLEOZoWSAMlACHNnG+yw5HDmse0oe+GW6U1u+ULdEB3UHiVWaHoJSSONV7tlcVxuaMy74sREDkSvg=="],
+    "@shikijs/transformers": ["@shikijs/transformers@3.7.0", "", { "dependencies": { "@shikijs/core": "3.7.0", "@shikijs/types": "3.7.0" } }, "sha512-VplaqIMRNsNOorCXJHkbF5S0pT6xm8Z/s7w7OPZLohf8tR93XH0krvUafpNy/ozEylrWuShJF0+ftEB+wFRwGA=="],
 
-    "@shikijs/types": ["@shikijs/types@3.4.2", "", { "dependencies": { "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-zHC1l7L+eQlDXLnxvM9R91Efh2V4+rN3oMVS2swCBssbj2U/FBwybD1eeLaq8yl/iwT+zih8iUbTBCgGZOYlVg=="],
+    "@shikijs/types": ["@shikijs/types@3.7.0", "", { "dependencies": { "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-MGaLeaRlSWpnP0XSAum3kP3a8vtcTsITqoEPYdt3lQG3YCdQH4DnEhodkYcNMcU0uW0RffhoD1O3e0vG5eSBBg=="],
 
     "@shikijs/vscode-textmate": ["@shikijs/vscode-textmate@10.0.2", "", {}, "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg=="],
 
@@ -1058,7 +1065,7 @@
 
     "@smithy/config-resolver": ["@smithy/config-resolver@4.1.4", "", { "dependencies": { "@smithy/node-config-provider": "^4.1.3", "@smithy/types": "^4.3.1", "@smithy/util-config-provider": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "tslib": "^2.6.2" } }, "sha512-prmU+rDddxHOH0oNcwemL+SwnzcG65sBF2yXRO7aeXIn/xTlq2pX7JLVbkBnVLowHLg4/OL4+jBmv9hVrVGS+w=="],
 
-    "@smithy/core": ["@smithy/core@3.5.1", "", { "dependencies": { "@smithy/middleware-serde": "^4.0.8", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-xSw7bZEFKwOKrm/iv8e2BLt2ur98YZdrRD6nII8ditQeUsY2Q1JmIQ0rpILOhaLKYxxG2ivnoOpokzr9qLyDWA=="],
+    "@smithy/core": ["@smithy/core@3.5.3", "", { "dependencies": { "@smithy/middleware-serde": "^4.0.8", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-base64": "^4.0.0", "@smithy/util-body-length-browser": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "@smithy/util-stream": "^4.2.2", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-xa5byV9fEguZNofCclv6v9ra0FYh5FATQW/da7FQUVTic94DfrN/NvmKZjrMyzbpqfot9ZjBaO8U1UeTbmSLuA=="],
 
     "@smithy/credential-provider-imds": ["@smithy/credential-provider-imds@4.0.6", "", { "dependencies": { "@smithy/node-config-provider": "^4.1.3", "@smithy/property-provider": "^4.0.4", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "tslib": "^2.6.2" } }, "sha512-hKMWcANhUiNbCJouYkZ9V3+/Qf9pteR1dnwgdyzR09R4ODEYx8BbUysHwRSyex4rZ9zapddZhLFTnT4ZijR4pw=="],
 
@@ -1088,9 +1095,9 @@
 
     "@smithy/middleware-content-length": ["@smithy/middleware-content-length@4.0.4", "", { "dependencies": { "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-F7gDyfI2BB1Kc+4M6rpuOLne5LOcEknH1n6UQB69qv+HucXBR1rkzXBnQTB2q46sFy1PM/zuSJOB532yc8bg3w=="],
 
-    "@smithy/middleware-endpoint": ["@smithy/middleware-endpoint@4.1.9", "", { "dependencies": { "@smithy/core": "^3.5.1", "@smithy/middleware-serde": "^4.0.8", "@smithy/node-config-provider": "^4.1.3", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-middleware": "^4.0.4", "tslib": "^2.6.2" } }, "sha512-AjDgX4UjORLltD/LZCBQTwjQqEfyrx/GeDTHcYLzIgf87pIT70tMWnN87NQpJru1K4ITirY2htSOxNECZJCBOg=="],
+    "@smithy/middleware-endpoint": ["@smithy/middleware-endpoint@4.1.11", "", { "dependencies": { "@smithy/core": "^3.5.3", "@smithy/middleware-serde": "^4.0.8", "@smithy/node-config-provider": "^4.1.3", "@smithy/shared-ini-file-loader": "^4.0.4", "@smithy/types": "^4.3.1", "@smithy/url-parser": "^4.0.4", "@smithy/util-middleware": "^4.0.4", "tslib": "^2.6.2" } }, "sha512-zDogwtRLzKl58lVS8wPcARevFZNBOOqnmzWWxVe9XiaXU2CADFjvJ9XfNibgkOWs08sxLuSr81NrpY4mgp9OwQ=="],
 
-    "@smithy/middleware-retry": ["@smithy/middleware-retry@4.1.10", "", { "dependencies": { "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/service-error-classification": "^4.0.5", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "tslib": "^2.6.2", "uuid": "^9.0.1" } }, "sha512-RyhcA3sZIIvAo6r48b2Nx2qfg0OnyohlaV0fw415xrQyx5HQ2bvHl9vs/WBiDXIP49mCfws5wX4308c9Pi/isw=="],
+    "@smithy/middleware-retry": ["@smithy/middleware-retry@4.1.12", "", { "dependencies": { "@smithy/node-config-provider": "^4.1.3", "@smithy/protocol-http": "^5.1.2", "@smithy/service-error-classification": "^4.0.5", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "@smithy/util-middleware": "^4.0.4", "@smithy/util-retry": "^4.0.5", "tslib": "^2.6.2", "uuid": "^9.0.1" } }, "sha512-wvIH70c4e91NtRxdaLZF+mbLZ/HcC6yg7ySKUiufL6ESp6zJUSnJucZ309AvG9nqCFHSRB5I6T3Ez1Q9wCh0Ww=="],
 
     "@smithy/middleware-serde": ["@smithy/middleware-serde@4.0.8", "", { "dependencies": { "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-iSSl7HJoJaGyMIoNn2B7czghOVwJ9nD7TMvLhMWeSB5vt0TnEYyRRqPJu/TqW76WScaNvYYB8nRoiBHR9S1Ddw=="],
 
@@ -1114,7 +1121,7 @@
 
     "@smithy/signature-v4": ["@smithy/signature-v4@5.1.2", "", { "dependencies": { "@smithy/is-array-buffer": "^4.0.0", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-hex-encoding": "^4.0.0", "@smithy/util-middleware": "^4.0.4", "@smithy/util-uri-escape": "^4.0.0", "@smithy/util-utf8": "^4.0.0", "tslib": "^2.6.2" } }, "sha512-d3+U/VpX7a60seHziWnVZOHuEgJlclufjkS6zhXvxcJgkJq4UWdH5eOBLzHRMx6gXjsdT9h6lfpmLzbrdupHgQ=="],
 
-    "@smithy/smithy-client": ["@smithy/smithy-client@4.4.1", "", { "dependencies": { "@smithy/core": "^3.5.1", "@smithy/middleware-endpoint": "^4.1.9", "@smithy/middleware-stack": "^4.0.4", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-stream": "^4.2.2", "tslib": "^2.6.2" } }, "sha512-XPbcHRfd0iwx8dY5XCBCGyI7uweMW0oezYezxXcG8ANgvZ5YPuC6Ylh+n0bTHpdU3SCMZOnhzgVklYz+p3fIhw=="],
+    "@smithy/smithy-client": ["@smithy/smithy-client@4.4.3", "", { "dependencies": { "@smithy/core": "^3.5.3", "@smithy/middleware-endpoint": "^4.1.11", "@smithy/middleware-stack": "^4.0.4", "@smithy/protocol-http": "^5.1.2", "@smithy/types": "^4.3.1", "@smithy/util-stream": "^4.2.2", "tslib": "^2.6.2" } }, "sha512-xxzNYgA0HD6ETCe5QJubsxP0hQH3QK3kbpJz3QrosBCuIWyEXLR/CO5hFb2OeawEKUxMNhz3a1nuJNN2np2RMA=="],
 
     "@smithy/types": ["@smithy/types@4.3.1", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-UqKOQBL2x6+HWl3P+3QqFD4ncKq0I8Nuz9QItGv5WuKuMHuuwlhvqcZCoXGfc+P1QmfJE7VieykoYYmrOoFJxA=="],
 
@@ -1130,9 +1137,9 @@
 
     "@smithy/util-config-provider": ["@smithy/util-config-provider@4.0.0", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-L1RBVzLyfE8OXH+1hsJ8p+acNUSirQnWQ6/EgpchV88G6zGBTDPdXiiExei6Z1wR2RxYvxY/XLw6AMNCCt8H3w=="],
 
-    "@smithy/util-defaults-mode-browser": ["@smithy/util-defaults-mode-browser@4.0.17", "", { "dependencies": { "@smithy/property-provider": "^4.0.4", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "bowser": "^2.11.0", "tslib": "^2.6.2" } }, "sha512-HXq5181qnXmIwB7VrwqwP8rsJybHMoYuJnNoXy4PROs2pfSI4sWDMASF2i+7Lo+u64Y6xowhegcdxczowgJtZg=="],
+    "@smithy/util-defaults-mode-browser": ["@smithy/util-defaults-mode-browser@4.0.19", "", { "dependencies": { "@smithy/property-provider": "^4.0.4", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "bowser": "^2.11.0", "tslib": "^2.6.2" } }, "sha512-mvLMh87xSmQrV5XqnUYEPoiFFeEGYeAKIDDKdhE2ahqitm8OHM3aSvhqL6rrK6wm1brIk90JhxDf5lf2hbrLbQ=="],
 
-    "@smithy/util-defaults-mode-node": ["@smithy/util-defaults-mode-node@4.0.17", "", { "dependencies": { "@smithy/config-resolver": "^4.1.4", "@smithy/credential-provider-imds": "^4.0.6", "@smithy/node-config-provider": "^4.1.3", "@smithy/property-provider": "^4.0.4", "@smithy/smithy-client": "^4.4.1", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-RfU2A5LjFhEHw4Nwl1GZNitK4AUWu5jGtigAUDoQtfDUvYHpQxcuLw2QGAdKDtKRflIiHSZ8wXBDR36H9R2Ang=="],
+    "@smithy/util-defaults-mode-node": ["@smithy/util-defaults-mode-node@4.0.19", "", { "dependencies": { "@smithy/config-resolver": "^4.1.4", "@smithy/credential-provider-imds": "^4.0.6", "@smithy/node-config-provider": "^4.1.3", "@smithy/property-provider": "^4.0.4", "@smithy/smithy-client": "^4.4.3", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-8tYnx+LUfj6m+zkUUIrIQJxPM1xVxfRBvoGHua7R/i6qAxOMjqR6CpEpDwKoIs1o0+hOjGvkKE23CafKL0vJ9w=="],
 
     "@smithy/util-endpoints": ["@smithy/util-endpoints@3.0.6", "", { "dependencies": { "@smithy/node-config-provider": "^4.1.3", "@smithy/types": "^4.3.1", "tslib": "^2.6.2" } }, "sha512-YARl3tFL3WgPuLzljRUnrS2ngLiUtkwhQtj8PAL13XZSyUiNLQxwG3fBBq3QXFqGFUXepIN73pINp3y8c2nBmA=="],
 
@@ -1168,35 +1175,35 @@
 
     "@tabler/icons-react": ["@tabler/icons-react@3.34.0", "", { "dependencies": { "@tabler/icons": "3.34.0" }, "peerDependencies": { "react": ">= 16" } }, "sha512-OpEIR2iZsIXECtAIMbn1zfKfQ3zKJjXyIZlkgOGUL9UkMCFycEiF2Y8AVfEQsyre/3FnBdlWJvGr0NU47n2TbQ=="],
 
-    "@tailwindcss/node": ["@tailwindcss/node@4.1.8", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "enhanced-resolve": "^5.18.1", "jiti": "^2.4.2", "lightningcss": "1.30.1", "magic-string": "^0.30.17", "source-map-js": "^1.2.1", "tailwindcss": "4.1.8" } }, "sha512-OWwBsbC9BFAJelmnNcrKuf+bka2ZxCE2A4Ft53Tkg4uoiE67r/PMEYwCsourC26E+kmxfwE0hVzMdxqeW+xu7Q=="],
+    "@tailwindcss/node": ["@tailwindcss/node@4.1.10", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "enhanced-resolve": "^5.18.1", "jiti": "^2.4.2", "lightningcss": "1.30.1", "magic-string": "^0.30.17", "source-map-js": "^1.2.1", "tailwindcss": "4.1.10" } }, "sha512-2ACf1znY5fpRBwRhMgj9ZXvb2XZW8qs+oTfotJ2C5xR0/WNL7UHZ7zXl6s+rUqedL1mNi+0O+WQr5awGowS3PQ=="],
 
-    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.1.8", "", { "dependencies": { "detect-libc": "^2.0.4", "tar": "^7.4.3" }, "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.1.8", "@tailwindcss/oxide-darwin-arm64": "4.1.8", "@tailwindcss/oxide-darwin-x64": "4.1.8", "@tailwindcss/oxide-freebsd-x64": "4.1.8", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.8", "@tailwindcss/oxide-linux-arm64-gnu": "4.1.8", "@tailwindcss/oxide-linux-arm64-musl": "4.1.8", "@tailwindcss/oxide-linux-x64-gnu": "4.1.8", "@tailwindcss/oxide-linux-x64-musl": "4.1.8", "@tailwindcss/oxide-wasm32-wasi": "4.1.8", "@tailwindcss/oxide-win32-arm64-msvc": "4.1.8", "@tailwindcss/oxide-win32-x64-msvc": "4.1.8" } }, "sha512-d7qvv9PsM5N3VNKhwVUhpK6r4h9wtLkJ6lz9ZY9aeZgrUWk1Z8VPyqyDT9MZlem7GTGseRQHkeB1j3tC7W1P+A=="],
+    "@tailwindcss/oxide": ["@tailwindcss/oxide@4.1.10", "", { "dependencies": { "detect-libc": "^2.0.4", "tar": "^7.4.3" }, "optionalDependencies": { "@tailwindcss/oxide-android-arm64": "4.1.10", "@tailwindcss/oxide-darwin-arm64": "4.1.10", "@tailwindcss/oxide-darwin-x64": "4.1.10", "@tailwindcss/oxide-freebsd-x64": "4.1.10", "@tailwindcss/oxide-linux-arm-gnueabihf": "4.1.10", "@tailwindcss/oxide-linux-arm64-gnu": "4.1.10", "@tailwindcss/oxide-linux-arm64-musl": "4.1.10", "@tailwindcss/oxide-linux-x64-gnu": "4.1.10", "@tailwindcss/oxide-linux-x64-musl": "4.1.10", "@tailwindcss/oxide-wasm32-wasi": "4.1.10", "@tailwindcss/oxide-win32-arm64-msvc": "4.1.10", "@tailwindcss/oxide-win32-x64-msvc": "4.1.10" } }, "sha512-v0C43s7Pjw+B9w21htrQwuFObSkio2aV/qPx/mhrRldbqxbWJK6KizM+q7BF1/1CmuLqZqX3CeYF7s7P9fbA8Q=="],
 
-    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.1.8", "", { "os": "android", "cpu": "arm64" }, "sha512-Fbz7qni62uKYceWYvUjRqhGfZKwhZDQhlrJKGtnZfuNtHFqa8wmr+Wn74CTWERiW2hn3mN5gTpOoxWKk0jRxjg=="],
+    "@tailwindcss/oxide-android-arm64": ["@tailwindcss/oxide-android-arm64@4.1.10", "", { "os": "android", "cpu": "arm64" }, "sha512-VGLazCoRQ7rtsCzThaI1UyDu/XRYVyH4/EWiaSX6tFglE+xZB5cvtC5Omt0OQ+FfiIVP98su16jDVHDEIuH4iQ=="],
 
-    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.1.8", "", { "os": "darwin", "cpu": "arm64" }, "sha512-RdRvedGsT0vwVVDztvyXhKpsU2ark/BjgG0huo4+2BluxdXo8NDgzl77qh0T1nUxmM11eXwR8jA39ibvSTbi7A=="],
+    "@tailwindcss/oxide-darwin-arm64": ["@tailwindcss/oxide-darwin-arm64@4.1.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-ZIFqvR1irX2yNjWJzKCqTCcHZbgkSkSkZKbRM3BPzhDL/18idA8uWCoopYA2CSDdSGFlDAxYdU2yBHwAwx8euQ=="],
 
-    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.1.8", "", { "os": "darwin", "cpu": "x64" }, "sha512-t6PgxjEMLp5Ovf7uMb2OFmb3kqzVTPPakWpBIFzppk4JE4ix0yEtbtSjPbU8+PZETpaYMtXvss2Sdkx8Vs4XRw=="],
+    "@tailwindcss/oxide-darwin-x64": ["@tailwindcss/oxide-darwin-x64@4.1.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-eCA4zbIhWUFDXoamNztmS0MjXHSEJYlvATzWnRiTqJkcUteSjO94PoRHJy1Xbwp9bptjeIxxBHh+zBWFhttbrQ=="],
 
-    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.1.8", "", { "os": "freebsd", "cpu": "x64" }, "sha512-g8C8eGEyhHTqwPStSwZNSrOlyx0bhK/V/+zX0Y+n7DoRUzyS8eMbVshVOLJTDDC+Qn9IJnilYbIKzpB9n4aBsg=="],
+    "@tailwindcss/oxide-freebsd-x64": ["@tailwindcss/oxide-freebsd-x64@4.1.10", "", { "os": "freebsd", "cpu": "x64" }, "sha512-8/392Xu12R0cc93DpiJvNpJ4wYVSiciUlkiOHOSOQNH3adq9Gi/dtySK7dVQjXIOzlpSHjeCL89RUUI8/GTI6g=="],
 
-    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.1.8", "", { "os": "linux", "cpu": "arm" }, "sha512-Jmzr3FA4S2tHhaC6yCjac3rGf7hG9R6Gf2z9i9JFcuyy0u79HfQsh/thifbYTF2ic82KJovKKkIB6Z9TdNhCXQ=="],
+    "@tailwindcss/oxide-linux-arm-gnueabihf": ["@tailwindcss/oxide-linux-arm-gnueabihf@4.1.10", "", { "os": "linux", "cpu": "arm" }, "sha512-t9rhmLT6EqeuPT+MXhWhlRYIMSfh5LZ6kBrC4FS6/+M1yXwfCtp24UumgCWOAJVyjQwG+lYva6wWZxrfvB+NhQ=="],
 
-    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.1.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-qq7jXtO1+UEtCmCeBBIRDrPFIVI4ilEQ97qgBGdwXAARrUqSn/L9fUrkb1XP/mvVtoVeR2bt/0L77xx53bPZ/Q=="],
+    "@tailwindcss/oxide-linux-arm64-gnu": ["@tailwindcss/oxide-linux-arm64-gnu@4.1.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-3oWrlNlxLRxXejQ8zImzrVLuZ/9Z2SeKoLhtCu0hpo38hTO2iL86eFOu4sVR8cZc6n3z7eRXXqtHJECa6mFOvA=="],
 
-    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.1.8", "", { "os": "linux", "cpu": "arm64" }, "sha512-O6b8QesPbJCRshsNApsOIpzKt3ztG35gfX9tEf4arD7mwNinsoCKxkj8TgEE0YRjmjtO3r9FlJnT/ENd9EVefQ=="],
+    "@tailwindcss/oxide-linux-arm64-musl": ["@tailwindcss/oxide-linux-arm64-musl@4.1.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-saScU0cmWvg/Ez4gUmQWr9pvY9Kssxt+Xenfx1LG7LmqjcrvBnw4r9VjkFcqmbBb7GCBwYNcZi9X3/oMda9sqQ=="],
 
-    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.1.8", "", { "os": "linux", "cpu": "x64" }, "sha512-32iEXX/pXwikshNOGnERAFwFSfiltmijMIAbUhnNyjFr3tmWmMJWQKU2vNcFX0DACSXJ3ZWcSkzNbaKTdngH6g=="],
+    "@tailwindcss/oxide-linux-x64-gnu": ["@tailwindcss/oxide-linux-x64-gnu@4.1.10", "", { "os": "linux", "cpu": "x64" }, "sha512-/G3ao/ybV9YEEgAXeEg28dyH6gs1QG8tvdN9c2MNZdUXYBaIY/Gx0N6RlJzfLy/7Nkdok4kaxKPHKJUlAaoTdA=="],
 
-    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.1.8", "", { "os": "linux", "cpu": "x64" }, "sha512-s+VSSD+TfZeMEsCaFaHTaY5YNj3Dri8rST09gMvYQKwPphacRG7wbuQ5ZJMIJXN/puxPcg/nU+ucvWguPpvBDg=="],
+    "@tailwindcss/oxide-linux-x64-musl": ["@tailwindcss/oxide-linux-x64-musl@4.1.10", "", { "os": "linux", "cpu": "x64" }, "sha512-LNr7X8fTiKGRtQGOerSayc2pWJp/9ptRYAa4G+U+cjw9kJZvkopav1AQc5HHD+U364f71tZv6XamaHKgrIoVzA=="],
 
-    "@tailwindcss/oxide-wasm32-wasi": ["@tailwindcss/oxide-wasm32-wasi@4.1.8", "", { "dependencies": { "@emnapi/core": "^1.4.3", "@emnapi/runtime": "^1.4.3", "@emnapi/wasi-threads": "^1.0.2", "@napi-rs/wasm-runtime": "^0.2.10", "@tybys/wasm-util": "^0.9.0", "tslib": "^2.8.0" }, "cpu": "none" }, "sha512-CXBPVFkpDjM67sS1psWohZ6g/2/cd+cq56vPxK4JeawelxwK4YECgl9Y9TjkE2qfF+9/s1tHHJqrC4SS6cVvSg=="],
+    "@tailwindcss/oxide-wasm32-wasi": ["@tailwindcss/oxide-wasm32-wasi@4.1.10", "", { "dependencies": { "@emnapi/core": "^1.4.3", "@emnapi/runtime": "^1.4.3", "@emnapi/wasi-threads": "^1.0.2", "@napi-rs/wasm-runtime": "^0.2.10", "@tybys/wasm-util": "^0.9.0", "tslib": "^2.8.0" }, "cpu": "none" }, "sha512-d6ekQpopFQJAcIK2i7ZzWOYGZ+A6NzzvQ3ozBvWFdeyqfOZdYHU66g5yr+/HC4ipP1ZgWsqa80+ISNILk+ae/Q=="],
 
-    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.1.8", "", { "os": "win32", "cpu": "arm64" }, "sha512-7GmYk1n28teDHUjPlIx4Z6Z4hHEgvP5ZW2QS9ygnDAdI/myh3HTHjDqtSqgu1BpRoI4OiLx+fThAyA1JePoENA=="],
+    "@tailwindcss/oxide-win32-arm64-msvc": ["@tailwindcss/oxide-win32-arm64-msvc@4.1.10", "", { "os": "win32", "cpu": "arm64" }, "sha512-i1Iwg9gRbwNVOCYmnigWCCgow8nDWSFmeTUU5nbNx3rqbe4p0kRbEqLwLJbYZKmSSp23g4N6rCDmm7OuPBXhDA=="],
 
-    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.1.8", "", { "os": "win32", "cpu": "x64" }, "sha512-fou+U20j+Jl0EHwK92spoWISON2OBnCazIc038Xj2TdweYV33ZRkS9nwqiUi2d/Wba5xg5UoHfvynnb/UB49cQ=="],
+    "@tailwindcss/oxide-win32-x64-msvc": ["@tailwindcss/oxide-win32-x64-msvc@4.1.10", "", { "os": "win32", "cpu": "x64" }, "sha512-sGiJTjcBSfGq2DVRtaSljq5ZgZS2SDHSIfhOylkBvHVjwOsodBhnb3HdmiKkVuUGKD0I7G63abMOVaskj1KpOA=="],
 
-    "@tailwindcss/postcss": ["@tailwindcss/postcss@4.1.8", "", { "dependencies": { "@alloc/quick-lru": "^5.2.0", "@tailwindcss/node": "4.1.8", "@tailwindcss/oxide": "4.1.8", "postcss": "^8.4.41", "tailwindcss": "4.1.8" } }, "sha512-vB/vlf7rIky+w94aWMw34bWW1ka6g6C3xIOdICKX2GC0VcLtL6fhlLiafF0DVIwa9V6EHz8kbWMkS2s2QvvNlw=="],
+    "@tailwindcss/postcss": ["@tailwindcss/postcss@4.1.10", "", { "dependencies": { "@alloc/quick-lru": "^5.2.0", "@tailwindcss/node": "4.1.10", "@tailwindcss/oxide": "4.1.10", "postcss": "^8.4.41", "tailwindcss": "4.1.10" } }, "sha512-B+7r7ABZbkXJwpvt2VMnS6ujcDoR2OOcFaqrLIo1xbcdxje4Vf+VgJdBzNNbrAjBj/rLZ66/tlQ1knIGNLKOBQ=="],
 
     "@testing-library/dom": ["@testing-library/dom@10.4.0", "", { "dependencies": { "@babel/code-frame": "^7.10.4", "@babel/runtime": "^7.12.5", "@types/aria-query": "^5.0.1", "aria-query": "5.3.0", "chalk": "^4.1.0", "dom-accessibility-api": "^0.5.9", "lz-string": "^1.5.0", "pretty-format": "^27.0.2" } }, "sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ=="],
 
@@ -1224,7 +1231,7 @@
 
     "@types/connect": ["@types/connect@3.4.38", "", { "dependencies": { "@types/node": "*" } }, "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug=="],
 
-    "@types/cors": ["@types/cors@2.8.18", "", { "dependencies": { "@types/node": "*" } }, "sha512-nX3d0sxJW41CqQvfOzVG1NCTXfFDrDWIghCZncpHeWlVFd81zxB/DLhg7avFg6eHLCRX7ckBmoIIcqa++upvJA=="],
+    "@types/cors": ["@types/cors@2.8.19", "", { "dependencies": { "@types/node": "*" } }, "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg=="],
 
     "@types/d3": ["@types/d3@7.4.3", "", { "dependencies": { "@types/d3-array": "*", "@types/d3-axis": "*", "@types/d3-brush": "*", "@types/d3-chord": "*", "@types/d3-color": "*", "@types/d3-contour": "*", "@types/d3-delaunay": "*", "@types/d3-dispatch": "*", "@types/d3-drag": "*", "@types/d3-dsv": "*", "@types/d3-ease": "*", "@types/d3-fetch": "*", "@types/d3-force": "*", "@types/d3-format": "*", "@types/d3-geo": "*", "@types/d3-hierarchy": "*", "@types/d3-interpolate": "*", "@types/d3-path": "*", "@types/d3-polygon": "*", "@types/d3-quadtree": "*", "@types/d3-random": "*", "@types/d3-scale": "*", "@types/d3-scale-chromatic": "*", "@types/d3-selection": "*", "@types/d3-shape": "*", "@types/d3-time": "*", "@types/d3-time-format": "*", "@types/d3-timer": "*", "@types/d3-transition": "*", "@types/d3-zoom": "*" } }, "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww=="],
 
@@ -1320,7 +1327,7 @@
 
     "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="],
 
-    "@types/lodash": ["@types/lodash@4.17.17", "", {}, "sha512-RRVJ+J3J+WmyOTqnz3PiBLA501eKwXl2noseKOrNo/6+XEHjTAxO4xHvxQB6QuNm+s4WRbn6rSiap8+EA+ykFQ=="],
+    "@types/lodash": ["@types/lodash@4.17.18", "", {}, "sha512-KJ65INaxqxmU6EoCiJmRPZC9H9RVWCRd349tXM2M3O5NA7cY6YL7c0bHAHQ93NOfTObEQ004kd2QVHs/r0+m4g=="],
 
     "@types/mdast": ["@types/mdast@4.0.4", "", { "dependencies": { "@types/unist": "*" } }, "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA=="],
 
@@ -1330,7 +1337,7 @@
 
     "@types/mysql": ["@types/mysql@2.15.26", "", { "dependencies": { "@types/node": "*" } }, "sha512-DSLCOXhkvfS5WNNPbfn2KdICAmk8lLc+/PNvnPnF7gOdMZCxopXduqv0OQ13y/yA/zXTSikZZqVgybUxOEg6YQ=="],
 
-    "@types/node": ["@types/node@22.15.29", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-LNdjOkUDlU1RZb8e1kOIUpN1qQUlzGkEtbVNo53vbrwDg5om6oduhm4SiUaPW5ASTXhAiP0jInWG8Qx9fVlOeQ=="],
+    "@types/node": ["@types/node@22.15.32", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-3jigKqgSjsH6gYZv2nEsqdXfZqIFGAV36XYYjf9KGZ3PSG+IhLecqPnI310RvjutyMwifE2hhhNEklOUrvx/wA=="],
 
     "@types/node-fetch": ["@types/node-fetch@2.6.12", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.0" } }, "sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA=="],
 
@@ -1342,9 +1349,9 @@
 
     "@types/prismjs": ["@types/prismjs@1.26.5", "", {}, "sha512-AUZTa7hQ2KY5L7AmtSiqxlhWxb4ina0yd8hNbl4TWuqnv/pFP0nDMb3YrfSBf4hJVGLh2YEIBfKaBW/9UEl6IQ=="],
 
-    "@types/react": ["@types/react@19.1.6", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-JeG0rEWak0N6Itr6QUx+X60uQmN+5t3j9r/OVDtWzFXKaj6kD1BwJzOksD0FF6iWxZlbE1kB0q9vtnU2ekqa1Q=="],
+    "@types/react": ["@types/react@19.1.8", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g=="],
 
-    "@types/react-dom": ["@types/react-dom@19.1.5", "", { "peerDependencies": { "@types/react": "^19.0.0" } }, "sha512-CMCjrWucUBZvohgZxkjd6S9h0nZxXjzus6yDfUb+xLxYM7VvjKNH1tQrE9GWLql1XoOP4/Ds3bwFqShHUYraGg=="],
+    "@types/react-dom": ["@types/react-dom@19.1.6", "", { "peerDependencies": { "@types/react": "^19.0.0" } }, "sha512-4hOiT/dwO8Ko0gV1m/TJZYk3y0KBnY9vzDh7W+DH17b2HFSOGgdj33dhihPeuy3l0q23+4e+hoXHV6hCC4dCXw=="],
 
     "@types/shimmer": ["@types/shimmer@1.2.0", "", {}, "sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg=="],
 
@@ -1360,6 +1367,8 @@
 
     "@types/unist": ["@types/unist@3.0.3", "", {}, "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q=="],
 
+    "@types/uuid": ["@types/uuid@9.0.8", "", {}, "sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA=="],
+
     "@types/webxr": ["@types/webxr@0.5.22", "", {}, "sha512-Vr6Stjv5jPRqH690f5I5GLjVk8GSsoQSYJ2FVd/3jJF7KaqfwPi3ehfBS96mlQ2kPCwZaX6U0rG2+NGHBKkA/A=="],
 
     "@types/xlsx": ["@types/xlsx@0.0.36", "", { "dependencies": { "xlsx": "*" } }, "sha512-mvfrKiKKMErQzLMF8ElYEH21qxWCZtN59pHhWGmWCWFJStYdMWjkDSAy6mGowFxHXaXZWe5/TW7pBUiWclIVOw=="],
@@ -1378,23 +1387,23 @@
 
     "@vercel/speed-insights": ["@vercel/speed-insights@1.2.0", "", { "peerDependencies": { "@sveltejs/kit": "^1 || ^2", "next": ">= 13", "react": "^18 || ^19 || ^19.0.0-rc", "svelte": ">= 4", "vue": "^3", "vue-router": "^4" }, "optionalPeers": ["@sveltejs/kit", "next", "react", "svelte", "vue", "vue-router"] }, "sha512-y9GVzrUJ2xmgtQlzFP2KhVRoCglwfRQgjyfY607aU0hh0Un6d0OUyrJkjuAlsV18qR4zfoFPs/BiIj9YDS6Wzw=="],
 
-    "@vitejs/plugin-react": ["@vitejs/plugin-react@4.5.0", "", { "dependencies": { "@babel/core": "^7.26.10", "@babel/plugin-transform-react-jsx-self": "^7.25.9", "@babel/plugin-transform-react-jsx-source": "^7.25.9", "@rolldown/pluginutils": "1.0.0-beta.9", "@types/babel__core": "^7.20.5", "react-refresh": "^0.17.0" }, "peerDependencies": { "vite": "^4.2.0 || ^5.0.0 || ^6.0.0" } }, "sha512-JuLWaEqypaJmOJPLWwO335Ig6jSgC1FTONCWAxnqcQthLTK/Yc9aH6hr9z/87xciejbQcnP3GnA1FWUSWeXaeg=="],
+    "@vitejs/plugin-react": ["@vitejs/plugin-react@4.5.2", "", { "dependencies": { "@babel/core": "^7.27.4", "@babel/plugin-transform-react-jsx-self": "^7.27.1", "@babel/plugin-transform-react-jsx-source": "^7.27.1", "@rolldown/pluginutils": "1.0.0-beta.11", "@types/babel__core": "^7.20.5", "react-refresh": "^0.17.0" }, "peerDependencies": { "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0-beta.0" } }, "sha512-QNVT3/Lxx99nMQWJWF7K4N6apUEuT0KlZA3mx/mVaoGj3smm/8rc8ezz15J1pcbcjDK0V15rpHetVfya08r76Q=="],
 
-    "@vitest/coverage-v8": ["@vitest/coverage-v8@3.2.0", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "@bcoe/v8-coverage": "^1.0.2", "ast-v8-to-istanbul": "^0.3.3", "debug": "^4.4.1", "istanbul-lib-coverage": "^3.2.2", "istanbul-lib-report": "^3.0.1", "istanbul-lib-source-maps": "^5.0.6", "istanbul-reports": "^3.1.7", "magic-string": "^0.30.17", "magicast": "^0.3.5", "std-env": "^3.9.0", "test-exclude": "^7.0.1", "tinyrainbow": "^2.0.0" }, "peerDependencies": { "@vitest/browser": "3.2.0", "vitest": "3.2.0" }, "optionalPeers": ["@vitest/browser"] }, "sha512-HjgvaokAiHxRMI5ioXl4WmgAi4zQtKtnltOOlmpzUqApdcTTZrZJAastbbRGydtiqwtYLFaIb6Jpo3PzowZ0cg=="],
+    "@vitest/coverage-v8": ["@vitest/coverage-v8@3.2.4", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "@bcoe/v8-coverage": "^1.0.2", "ast-v8-to-istanbul": "^0.3.3", "debug": "^4.4.1", "istanbul-lib-coverage": "^3.2.2", "istanbul-lib-report": "^3.0.1", "istanbul-lib-source-maps": "^5.0.6", "istanbul-reports": "^3.1.7", "magic-string": "^0.30.17", "magicast": "^0.3.5", "std-env": "^3.9.0", "test-exclude": "^7.0.1", "tinyrainbow": "^2.0.0" }, "peerDependencies": { "@vitest/browser": "3.2.4", "vitest": "3.2.4" }, "optionalPeers": ["@vitest/browser"] }, "sha512-EyF9SXU6kS5Ku/U82E259WSnvg6c8KTjppUncuNdm5QHpe17mwREHnjDzozC8x9MZ0xfBUFSaLkRv4TMA75ALQ=="],
 
-    "@vitest/expect": ["@vitest/expect@3.2.0", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/spy": "3.2.0", "@vitest/utils": "3.2.0", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-0v4YVbhDKX3SKoy0PHWXpKhj44w+3zZkIoVES9Ex2pq+u6+Bijijbi2ua5kE+h3qT6LBWFTNZSCOEU37H8Y5sA=="],
+    "@vitest/expect": ["@vitest/expect@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig=="],
 
-    "@vitest/mocker": ["@vitest/mocker@3.2.0", "", { "dependencies": { "@vitest/spy": "3.2.0", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw", "vite"] }, "sha512-HFcW0lAMx3eN9vQqis63H0Pscv0QcVMo1Kv8BNysZbxcmHu3ZUYv59DS6BGYiGQ8F5lUkmsfMMlPm4DJFJdf/A=="],
+    "@vitest/mocker": ["@vitest/mocker@3.2.4", "", { "dependencies": { "@vitest/spy": "3.2.4", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw", "vite"] }, "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ=="],
 
-    "@vitest/pretty-format": ["@vitest/pretty-format@3.2.0", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-gUUhaUmPBHFkrqnOokmfMGRBMHhgpICud9nrz/xpNV3/4OXCn35oG+Pl8rYYsKaTNd/FAIrqRHnwpDpmYxCYZw=="],
+    "@vitest/pretty-format": ["@vitest/pretty-format@3.2.4", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA=="],
 
-    "@vitest/runner": ["@vitest/runner@3.2.0", "", { "dependencies": { "@vitest/utils": "3.2.0", "pathe": "^2.0.3" } }, "sha512-bXdmnHxuB7fXJdh+8vvnlwi/m1zvu+I06i1dICVcDQFhyV4iKw2RExC/acavtDn93m/dRuawUObKsrNE1gJacA=="],
+    "@vitest/runner": ["@vitest/runner@3.2.4", "", { "dependencies": { "@vitest/utils": "3.2.4", "pathe": "^2.0.3", "strip-literal": "^3.0.0" } }, "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ=="],
 
-    "@vitest/snapshot": ["@vitest/snapshot@3.2.0", "", { "dependencies": { "@vitest/pretty-format": "3.2.0", "magic-string": "^0.30.17", "pathe": "^2.0.3" } }, "sha512-z7P/EneBRMe7hdvWhcHoXjhA6at0Q4ipcoZo6SqgxLyQQ8KSMMCmvw1cSt7FHib3ozt0wnRHc37ivuUMbxzG/A=="],
+    "@vitest/snapshot": ["@vitest/snapshot@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "magic-string": "^0.30.17", "pathe": "^2.0.3" } }, "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ=="],
 
-    "@vitest/spy": ["@vitest/spy@3.2.0", "", { "dependencies": { "tinyspy": "^4.0.3" } }, "sha512-s3+TkCNUIEOX99S0JwNDfsHRaZDDZZR/n8F0mop0PmsEbQGKZikCGpTGZ6JRiHuONKew3Fb5//EPwCP+pUX9cw=="],
+    "@vitest/spy": ["@vitest/spy@3.2.4", "", { "dependencies": { "tinyspy": "^4.0.3" } }, "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw=="],
 
-    "@vitest/utils": ["@vitest/utils@3.2.0", "", { "dependencies": { "@vitest/pretty-format": "3.2.0", "loupe": "^3.1.3", "tinyrainbow": "^2.0.0" } }, "sha512-gXXOe7Fj6toCsZKVQouTRLJftJwmvbhH5lKOBR6rlP950zUq9AitTUjnFoXS/CqjBC2aoejAztLPzzuva++XBw=="],
+    "@vitest/utils": ["@vitest/utils@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "loupe": "^3.1.4", "tinyrainbow": "^2.0.0" } }, "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA=="],
 
     "@webassemblyjs/ast": ["@webassemblyjs/ast@1.14.1", "", { "dependencies": { "@webassemblyjs/helper-numbers": "1.13.2", "@webassemblyjs/helper-wasm-bytecode": "1.13.2" } }, "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ=="],
 
@@ -1438,7 +1447,7 @@
 
     "accepts": ["accepts@1.3.8", "", { "dependencies": { "mime-types": "~2.1.34", "negotiator": "0.6.3" } }, "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw=="],
 
-    "acorn": ["acorn@8.14.1", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg=="],
+    "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
     "acorn-import-attributes": ["acorn-import-attributes@1.9.5", "", { "peerDependencies": { "acorn": "^8" } }, "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ=="],
 
@@ -1500,7 +1509,7 @@
 
     "base64id": ["base64id@2.0.0", "", {}, "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog=="],
 
-    "better-auth": ["better-auth@1.2.9", "", { "dependencies": { "@better-auth/utils": "0.2.5", "@better-fetch/fetch": "^1.1.18", "@noble/ciphers": "^0.6.0", "@noble/hashes": "^1.6.1", "@simplewebauthn/browser": "^13.0.0", "@simplewebauthn/server": "^13.0.0", "better-call": "^1.0.8", "defu": "^6.1.4", "jose": "^5.9.6", "kysely": "^0.28.2", "nanostores": "^0.11.3", "zod": "^3.24.1" } }, "sha512-WLqBXDzuaCQetQctLGC5oTfGmL32zUvxnM4Y+LZkhwseMaZWq5EKI+c/ZATgz2YkFt7726q659PF8CfB9P1VuA=="],
+    "better-auth": ["better-auth@1.2.10", "", { "dependencies": { "@better-auth/utils": "0.2.5", "@better-fetch/fetch": "^1.1.18", "@noble/ciphers": "^0.6.0", "@noble/hashes": "^1.6.1", "@simplewebauthn/browser": "^13.0.0", "@simplewebauthn/server": "^13.0.0", "better-call": "^1.0.8", "defu": "^6.1.4", "jose": "^5.9.6", "kysely": "^0.28.2", "nanostores": "^0.11.3", "zod": "^3.24.1" } }, "sha512-nEj1RG4DdLUuJiV5CR93ORyPCptGRBwksaPPCkUtGo9ka+UIlTpaiKoTaTqVLLYlqwX4bOj9tJ32oBNdf2G3Kg=="],
 
     "better-call": ["better-call@1.0.9", "", { "dependencies": { "@better-fetch/fetch": "^1.1.4", "rou3": "^0.5.1", "set-cookie-parser": "^2.7.1", "uncrypto": "^0.1.3" } }, "sha512-Qfm0gjk0XQz0oI7qvTK1hbqTsBY4xV2hsHAxF8LZfUYl3RaECCIifXuVqtPpZJWvlCCMlQSvkvhhyuApGUba6g=="],
 
@@ -1516,7 +1525,7 @@
 
     "bowser": ["bowser@2.11.0", "", {}, "sha512-AlcaJBi/pqqJBIQ8U9Mcpc9i8Aqxn88Skv5d+xBX006BY5u8N3mGLHa5Lgppa7L/HfwgwLgZ6NYs+Ag6uUmJRA=="],
 
-    "brace-expansion": ["brace-expansion@2.0.1", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA=="],
+    "brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="],
 
     "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
 
@@ -1548,7 +1557,7 @@
 
     "camelize": ["camelize@1.0.1", "", {}, "sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ=="],
 
-    "caniuse-lite": ["caniuse-lite@1.0.30001720", "", {}, "sha512-Ec/2yV2nNPwb4DnTANEV99ZWwm3ZWfdlfkQbWSDDt+PsXEVYwlhPH8tdMaPunYTKKmz7AnHi2oNEi1GcmKCD8g=="],
+    "caniuse-lite": ["caniuse-lite@1.0.30001724", "", {}, "sha512-WqJo7p0TbHDOythNTqYujmaJTvtYRZrjpP8TCvH6Vb9CYJerJNKamKzIWOM4BkQatWj9H2lYulpdAQNBe7QhNA=="],
 
     "capital-case": ["capital-case@1.0.4", "", { "dependencies": { "no-case": "^3.0.4", "tslib": "^2.0.3", "upper-case-first": "^2.0.2" } }, "sha512-ds37W8CytHgwnhGGTi88pcPyR15qoNkOpYwmMMfnWqqWgESapLqvDx6huFjQ5vqWSn2Z06173XNA7LtMOeUh1A=="],
 
@@ -1630,6 +1639,8 @@
 
     "compute-scroll-into-view": ["compute-scroll-into-view@3.1.1", "", {}, "sha512-VRhuHOLoKYOy4UbilLbUzbYg93XLjv2PncJC50EuTWPA3gaja1UjBsUP/D/9/juV3vQFr6XBEzn9KCAHdUvOHw=="],
 
+    "concurrently": ["concurrently@9.1.2", "", { "dependencies": { "chalk": "^4.1.2", "lodash": "^4.17.21", "rxjs": "^7.8.1", "shell-quote": "^1.8.1", "supports-color": "^8.1.1", "tree-kill": "^1.2.2", "yargs": "^17.7.2" }, "bin": { "conc": "dist/bin/concurrently.js", "concurrently": "dist/bin/concurrently.js" } }, "sha512-H9MWcoPsYddwbOGM6difjVwVZHl63nwMEwDJG/L7VGtuaJhb12h2caPG2tVPWs7emuYix252iGfqOyrz1GczTQ=="],
+
     "constant-case": ["constant-case@3.0.4", "", { "dependencies": { "no-case": "^3.0.4", "tslib": "^2.0.3", "upper-case": "^2.0.2" } }, "sha512-I2hSBi7Vvs7BEuJDr5dDHfzb/Ruj3FyvFyh7KLilAjNQw3Be+xgqUBA2W6scVEcL0hL1dwPRtIqEPVUCKkSsyQ=="],
 
     "convert-source-map": ["convert-source-map@2.0.0", "", {}, "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg=="],
@@ -1646,7 +1657,7 @@
 
     "critters": ["critters@0.0.23", "", { "dependencies": { "chalk": "^4.1.0", "css-select": "^5.1.0", "dom-serializer": "^2.0.0", "domhandler": "^5.0.2", "htmlparser2": "^8.0.2", "postcss": "^8.4.23", "postcss-media-query-parser": "^0.2.3" } }, "sha512-/MCsQbuzTPA/ZTOjjyr2Na5o3lRpr8vd0MZE8tMP0OBNg/VrLxWHteVKalQ8KR+fBmUadbJLdoyEz9sT+q84qg=="],
 
-    "croner": ["croner@9.0.0", "", {}, "sha512-onMB0OkDjkXunhdW9htFjEhqrD54+M94i6ackoUkjHKbRnXdyEyKRelp4nJ1kAz32+s27jP1FsebpJCVl0BsvA=="],
+    "croner": ["croner@9.1.0", "", {}, "sha512-p9nwwR4qyT5W996vBZhdvBCnMhicY5ytZkR4D1Xj0wuTDEiMnjwR57Q3RXYY/s0EpX6Ay3vgIcfaR+ewGHsi+g=="],
 
     "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
 
@@ -1668,7 +1679,7 @@
 
     "cssesc": ["cssesc@3.0.0", "", { "bin": { "cssesc": "bin/cssesc" } }, "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg=="],
 
-    "cssstyle": ["cssstyle@4.3.1", "", { "dependencies": { "@asamuzakjp/css-color": "^3.1.2", "rrweb-cssom": "^0.8.0" } }, "sha512-ZgW+Jgdd7i52AaLYCriF8Mxqft0gD/R9i9wi6RWBhs1pqdPEzPjym7rvRKi397WmQFf3SlyUsszhw+VVCbx79Q=="],
+    "cssstyle": ["cssstyle@4.5.0", "", { "dependencies": { "@asamuzakjp/css-color": "^3.2.0", "rrweb-cssom": "^0.8.0" } }, "sha512-/7gw8TGrvH/0g564EnhgFZogTMVe+lifpB7LWU+PEsiq5o83TUXR3fDbzTRXOJhoJwck5IS9ez3Em5LNMMO2aw=="],
 
     "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
 
@@ -1726,7 +1737,7 @@
 
     "decimal.js-light": ["decimal.js-light@2.5.1", "", {}, "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg=="],
 
-    "decode-named-character-reference": ["decode-named-character-reference@1.1.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-Wy+JTSbFThEOXQIR2L6mxJvEs+veIzpmqD7ynWxMXGpnk3smkHQOp6forLdHsKpAMW9iJpaBBIxz285t1n1C3w=="],
+    "decode-named-character-reference": ["decode-named-character-reference@1.2.0", "", { "dependencies": { "character-entities": "^2.0.0" } }, "sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q=="],
 
     "deep-eql": ["deep-eql@5.0.2", "", {}, "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q=="],
 
@@ -1748,6 +1759,8 @@
 
     "devlop": ["devlop@1.1.0", "", { "dependencies": { "dequal": "^2.0.0" } }, "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA=="],
 
+    "devtools-protocol": ["devtools-protocol@0.0.1464554", "", {}, "sha512-CAoP3lYfwAGQTaAXYvA6JZR0fjGUb7qec1qf4mToyoH2TZgUFeIqYcjh6f9jNuhHfuZiEdH+PONHYrLhRQX6aw=="],
+
     "didyoumean": ["didyoumean@1.2.2", "", {}, "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw=="],
 
     "diff-match-patch": ["diff-match-patch@1.0.5", "", {}, "sha512-IayShXAgj/QMXgB0IWmKx+rOPuGMhqm5w6jvFxmVenXKIzRqTAAsbBPT3kWQeGANj3jGgvcvv4yK6SxqYmikgw=="],
@@ -1792,19 +1805,21 @@
 
     "ecdsa-sig-formatter": ["ecdsa-sig-formatter@1.0.11", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ=="],
 
-    "electron-to-chromium": ["electron-to-chromium@1.5.161", "", {}, "sha512-hwtetwfKNZo/UlwHIVBlKZVdy7o8bIZxxKs0Mv/ROPiQQQmDgdm5a+KvKtBsxM8ZjFzTaCeLoodZ8jiBE3o9rA=="],
+    "electron-to-chromium": ["electron-to-chromium@1.5.171", "", {}, "sha512-scWpzXEJEMrGJa4Y6m/tVotb0WuvNmasv3wWVzUAeCgKU0ToFOhUW6Z+xWnRQANMYGxN4ngJXIThgBJOqzVPCQ=="],
 
     "emoji-regex": ["emoji-regex@10.4.0", "", {}, "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw=="],
 
-    "end-of-stream": ["end-of-stream@1.4.4", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q=="],
+    "end-of-stream": ["end-of-stream@1.4.5", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg=="],
 
     "engine.io": ["engine.io@6.6.4", "", { "dependencies": { "@types/cors": "^2.8.12", "@types/node": ">=10.0.0", "accepts": "~1.3.4", "base64id": "2.0.0", "cookie": "~0.7.2", "cors": "~2.8.5", "debug": "~4.3.1", "engine.io-parser": "~5.2.1", "ws": "~8.17.1" } }, "sha512-ZCkIjSYNDyGn0R6ewHDtXgns/Zre/NT6Agvq1/WobF7JXgFff4SeDroKiCO3fNJreU9YG429Sc81o4w5ok/W5g=="],
 
+    "engine.io-client": ["engine.io-client@6.6.3", "", { "dependencies": { "@socket.io/component-emitter": "~3.1.0", "debug": "~4.3.1", "engine.io-parser": "~5.2.1", "ws": "~8.17.1", "xmlhttprequest-ssl": "~2.1.1" } }, "sha512-T0iLjnyNWahNyv/lcjS2y4oE358tVS/SYQNxYXGAJ9/GLgH4VCvOQ/mhTjqU88mLZCQgiG8RIegFHYCdVC+j5w=="],
+
     "engine.io-parser": ["engine.io-parser@5.2.3", "", {}, "sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q=="],
 
     "enhanced-resolve": ["enhanced-resolve@5.18.1", "", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.2.0" } }, "sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg=="],
 
-    "entities": ["entities@6.0.0", "", {}, "sha512-aKstq2TDOndCn4diEyp9Uq/Flu2i1GlLkc6XIDQSDMuaFE3OPW5OphLCyQ5SpSJZTb4reN+kTcYru5yIfXoRPw=="],
+    "entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="],
 
     "environment": ["environment@1.1.0", "", {}, "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q=="],
 
@@ -1870,8 +1885,6 @@
 
     "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],
 
-    "extend-shallow": ["extend-shallow@2.0.1", "", { "dependencies": { "is-extendable": "^0.1.0" } }, "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug=="],
-
     "external-editor": ["external-editor@3.1.0", "", { "dependencies": { "chardet": "^0.7.0", "iconv-lite": "^0.4.24", "tmp": "^0.0.33" } }, "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew=="],
 
     "fast-copy": ["fast-copy@3.0.2", "", {}, "sha512-dl0O9Vhju8IrcLndv2eU4ldt1ftXMqqfgN4H1cpmGV7P6jeB9FwpN9a2c8DPGE1Ys88rNUJVYDHq73CGAGOPfQ=="],
@@ -1892,10 +1905,12 @@
 
     "fastq": ["fastq@1.19.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ=="],
 
-    "fdir": ["fdir@6.4.5", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-4BG7puHpVsIYxZUbiUE3RqGloLaSSwzYie5jvasC4LWuBWzZawynvYouhjbQKw2JuIGYdm0DzIxl8iVidKlUEw=="],
+    "fdir": ["fdir@6.4.6", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w=="],
 
     "fetch-blob": ["fetch-blob@3.2.0", "", { "dependencies": { "node-domexception": "^1.0.0", "web-streams-polyfill": "^3.0.3" } }, "sha512-7yAQpD2UMJzLi1Dqv7qFYnPbaPx7ZfFK6PiIxQ4PfkGPyNyl2Ugx+a/umUonmKqjhM4DnfbMvdX6otXq83soQQ=="],
 
+    "fetch-cookie": ["fetch-cookie@3.1.0", "", { "dependencies": { "set-cookie-parser": "^2.4.8", "tough-cookie": "^5.0.0" } }, "sha512-s/XhhreJpqH0ftkGVcQt8JE9bqk+zRn4jF5mPJXWZeQMCI5odV9K+wEWYbnzFPHgQZlvPSMjS4n4yawWE8RINw=="],
+
     "fflate": ["fflate@0.8.2", "", {}, "sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A=="],
 
     "figures": ["figures@3.2.0", "", { "dependencies": { "escape-string-regexp": "^1.0.5" } }, "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg=="],
@@ -1906,7 +1921,7 @@
 
     "foreground-child": ["foreground-child@3.3.1", "", { "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" } }, "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw=="],
 
-    "form-data": ["form-data@4.0.2", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "mime-types": "^2.1.12" } }, "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w=="],
+    "form-data": ["form-data@4.0.3", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-qsITQPfmvMOSAdeyZ+12I1c+CKSstAFAwu+97zrnWAbIr5u8wfsExUzCesVLC8NgHuRUqNN4Zy6UPWUTRGslcA=="],
 
     "form-data-encoder": ["form-data-encoder@1.7.2", "", {}, "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A=="],
 
@@ -1918,7 +1933,7 @@
 
     "frac": ["frac@1.1.2", "", {}, "sha512-w/XBfkibaTl3YDqASwfDUqkna4Z2p9cFSr1aHDt0WoMTECnRfBOv2WArlZILlqgWlmdIlALXGpM2AOhEk5W3IA=="],
 
-    "framer-motion": ["framer-motion@12.15.0", "", { "dependencies": { "motion-dom": "^12.15.0", "motion-utils": "^12.12.1", "tslib": "^2.4.0" }, "peerDependencies": { "@emotion/is-prop-valid": "*", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@emotion/is-prop-valid", "react", "react-dom"] }, "sha512-XKg/LnKExdLGugZrDILV7jZjI599785lDIJZLxMiiIFidCsy0a4R2ZEf+Izm67zyOuJgQYTHOmodi7igQsw3vg=="],
+    "framer-motion": ["framer-motion@12.18.1", "", { "dependencies": { "motion-dom": "^12.18.1", "motion-utils": "^12.18.1", "tslib": "^2.4.0" }, "peerDependencies": { "@emotion/is-prop-valid": "*", "react": "^18.0.0 || ^19.0.0", "react-dom": "^18.0.0 || ^19.0.0" }, "optionalPeers": ["@emotion/is-prop-valid", "react", "react-dom"] }, "sha512-6o4EDuRPLk4LSZ1kRnnEOurbQ86MklVk+Y1rFBUKiF+d2pCdvMjWVu0ZkyMVCTwl5UyTH2n/zJEJx+jvTYuxow=="],
 
     "freestyle-sandboxes": ["freestyle-sandboxes@0.0.38", "", { "dependencies": { "@hey-api/client-fetch": "^0.5.7", "glob": "^11.0.1", "openai": "^4.77.3", "openapi": "^1.0.1", "zod": "^3.24.1" } }, "sha512-g1h9NPbIw8Bhd9nTkcYeA3I/ghV6qqVt9ogwZDFU9KMWPM5VedWwFUz29eELdcqJ4dnpA1NznU67h5/lsKlhvA=="],
 
@@ -1926,11 +1941,11 @@
 
     "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
 
-    "fumadocs-core": ["fumadocs-core@15.5.0", "", { "dependencies": { "@formatjs/intl-localematcher": "^0.6.1", "@orama/orama": "^3.1.6", "@shikijs/rehype": "^3.4.2", "@shikijs/transformers": "^3.4.2", "github-slugger": "^2.0.0", "hast-util-to-estree": "^3.1.3", "hast-util-to-jsx-runtime": "^2.3.6", "image-size": "^2.0.2", "negotiator": "^1.0.0", "react-remove-scroll": "^2.6.3", "remark": "^15.0.0", "remark-gfm": "^4.0.1", "remark-rehype": "^11.1.2", "scroll-into-view-if-needed": "^3.1.0", "shiki": "^3.4.2", "unist-util-visit": "^5.0.0" }, "peerDependencies": { "@oramacloud/client": "1.x.x || 2.x.x", "algoliasearch": "5.x.x", "next": "14.x.x || 15.x.x", "react": "18.x.x || 19.x.x", "react-dom": "18.x.x || 19.x.x" }, "optionalPeers": ["@oramacloud/client", "algoliasearch", "next", "react", "react-dom"] }, "sha512-om0rmaYG8MidItR1dGuiNYX1MbSGUM1xEFfWpBCcJ9yI52FPGOJtZajWgAqqjvOVJk9Wl4m03sZdBjb4S8ra3g=="],
+    "fumadocs-core": ["fumadocs-core@15.5.3", "", { "dependencies": { "@formatjs/intl-localematcher": "^0.6.1", "@orama/orama": "^3.1.6", "@shikijs/rehype": "^3.6.0", "@shikijs/transformers": "^3.6.0", "github-slugger": "^2.0.0", "hast-util-to-estree": "^3.1.3", "hast-util-to-jsx-runtime": "^2.3.6", "image-size": "^2.0.2", "negotiator": "^1.0.0", "react-remove-scroll": "^2.7.1", "remark": "^15.0.0", "remark-gfm": "^4.0.1", "remark-rehype": "^11.1.2", "scroll-into-view-if-needed": "^3.1.0", "shiki": "^3.6.0", "unist-util-visit": "^5.0.0" }, "peerDependencies": { "@oramacloud/client": "1.x.x || 2.x.x", "@types/react": "*", "algoliasearch": "5.x.x", "next": "14.x.x || 15.x.x", "react": "18.x.x || 19.x.x", "react-dom": "18.x.x || 19.x.x" }, "optionalPeers": ["@oramacloud/client", "@types/react", "algoliasearch", "next", "react", "react-dom"] }, "sha512-FGOrPqUpovSkc25s7EzNvYO0Oi1mlAJz9GxJ3jb8W1v5rmtWgjVhpjs5vBNMQtKDpQuO0GjkHN5iMQVbW0DvjQ=="],
 
-    "fumadocs-mdx": ["fumadocs-mdx@11.6.6", "", { "dependencies": { "@mdx-js/mdx": "^3.1.0", "@standard-schema/spec": "^1.0.0", "chokidar": "^4.0.3", "esbuild": "^0.25.4", "estree-util-value-to-estree": "^3.4.0", "gray-matter": "^4.0.3", "js-yaml": "^4.1.0", "lru-cache": "^11.1.0", "picocolors": "^1.1.1", "tinyexec": "^1.0.1", "tinyglobby": "^0.2.13", "unist-util-visit": "^5.0.0", "zod": "^3.25.28" }, "peerDependencies": { "@fumadocs/mdx-remote": "^1.2.0", "fumadocs-core": "^14.0.0 || ^15.0.0", "next": "^15.3.0" }, "optionalPeers": ["@fumadocs/mdx-remote"], "bin": { "fumadocs-mdx": "bin.js" } }, "sha512-CRSrO2C8+hybQq6u97pB/FN3Hq1Y8FbTnqYfr1MzLdLCB7IsbfXu4KkkqJq4Tq4icGb68BpeLWDsSxDmrswNAA=="],
+    "fumadocs-mdx": ["fumadocs-mdx@11.6.9", "", { "dependencies": { "@mdx-js/mdx": "^3.1.0", "@standard-schema/spec": "^1.0.0", "chokidar": "^4.0.3", "esbuild": "^0.25.5", "estree-util-value-to-estree": "^3.4.0", "js-yaml": "^4.1.0", "lru-cache": "^11.1.0", "picocolors": "^1.1.1", "tinyexec": "^1.0.1", "tinyglobby": "^0.2.14", "unist-util-visit": "^5.0.0", "zod": "^3.25.63" }, "peerDependencies": { "@fumadocs/mdx-remote": "^1.2.0", "fumadocs-core": "^14.0.0 || ^15.0.0", "next": "^15.3.0", "vite": "6.x.x" }, "optionalPeers": ["@fumadocs/mdx-remote", "next", "vite"], "bin": { "fumadocs-mdx": "bin.js" } }, "sha512-Gm29CFOpvBe8m8r4Es0U6xsVvGaKEMiACsJeUYr6QdZiTYKXkl9a+gI6kkOfPJ/Aoyb561mh3Q0JSONX37GT5w=="],
 
-    "fumadocs-ui": ["fumadocs-ui@15.5.0", "", { "dependencies": { "@radix-ui/react-accordion": "^1.2.11", "@radix-ui/react-collapsible": "^1.1.11", "@radix-ui/react-dialog": "^1.1.14", "@radix-ui/react-direction": "^1.1.1", "@radix-ui/react-navigation-menu": "^1.2.13", "@radix-ui/react-popover": "^1.1.14", "@radix-ui/react-presence": "^1.1.4", "@radix-ui/react-scroll-area": "^1.2.9", "@radix-ui/react-slot": "^1.2.3", "@radix-ui/react-tabs": "^1.1.12", "class-variance-authority": "^0.7.1", "fumadocs-core": "15.5.0", "lodash.merge": "^4.6.2", "next-themes": "^0.4.6", "postcss-selector-parser": "^7.1.0", "react-medium-image-zoom": "^5.2.14", "react-remove-scroll": "^2.6.3", "tailwind-merge": "^3.3.0" }, "peerDependencies": { "next": "14.x.x || 15.x.x", "react": "18.x.x || 19.x.x", "react-dom": "18.x.x || 19.x.x", "tailwindcss": "^3.4.14 || ^4.0.0" }, "optionalPeers": ["tailwindcss"] }, "sha512-eUrbofXIlywHHgdWPKi99od/s3tp/SdlUVa/5+g4ppIi625iiWuP6MezYXNoNtcYkx7VcJd+2mGSusmQxP4EeA=="],
+    "fumadocs-ui": ["fumadocs-ui@15.5.3", "", { "dependencies": { "@radix-ui/react-accordion": "^1.2.11", "@radix-ui/react-collapsible": "^1.1.11", "@radix-ui/react-dialog": "^1.1.14", "@radix-ui/react-direction": "^1.1.1", "@radix-ui/react-navigation-menu": "^1.2.13", "@radix-ui/react-popover": "^1.1.14", "@radix-ui/react-presence": "^1.1.4", "@radix-ui/react-scroll-area": "^1.2.9", "@radix-ui/react-slot": "^1.2.3", "@radix-ui/react-tabs": "^1.1.12", "class-variance-authority": "^0.7.1", "fumadocs-core": "15.5.3", "lodash.merge": "^4.6.2", "next-themes": "^0.4.6", "postcss-selector-parser": "^7.1.0", "react-medium-image-zoom": "^5.2.14", "react-remove-scroll": "^2.7.1", "tailwind-merge": "^3.3.1" }, "peerDependencies": { "@types/react": "*", "next": "14.x.x || 15.x.x", "react": "18.x.x || 19.x.x", "react-dom": "18.x.x || 19.x.x", "tailwindcss": "^3.4.14 || ^4.0.0" }, "optionalPeers": ["@types/react", "next", "tailwindcss"] }, "sha512-5SmN1j7HBQ9XuboAicfFqoNLPpN37Iwz0+cCLt6cOOequurTjfPfYCjvlKzP5q0GxDjrpU2vEQX/9JMa25bC6w=="],
 
     "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
 
@@ -1954,7 +1969,7 @@
 
     "github-slugger": ["github-slugger@2.0.0", "", {}, "sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw=="],
 
-    "glob": ["glob@11.0.2", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^4.0.1", "minimatch": "^10.0.0", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-YT7U7Vye+t5fZ/QMkBFrTJ7ZQxInIUjwyAjVj84CYXqgBdv30MFUPGnBR6sQaVq6Is15wYJUsnzTuWaGRBhBAQ=="],
+    "glob": ["glob@11.0.3", "", { "dependencies": { "foreground-child": "^3.3.1", "jackspeak": "^4.1.1", "minimatch": "^10.0.3", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^2.0.0" }, "bin": { "glob": "dist/esm/bin.mjs" } }, "sha512-2Nim7dha1KVkaiF4q6Dj+ngPPMdfvLJEOpZk/jKiUAkqKebpGAWQXAq9z1xu9HKu5lWfqw/FASuccEjyznjPaA=="],
 
     "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
 
@@ -1974,8 +1989,6 @@
 
     "graphql": ["graphql@15.10.1", "", {}, "sha512-BL/Xd/T9baO6NFzoMpiMD7YUZ62R6viR5tp/MULVEnbYJXZA//kRNW7J0j1w/wXArgL0sCxhDfK5dczSKn3+cg=="],
 
-    "gray-matter": ["gray-matter@4.0.3", "", { "dependencies": { "js-yaml": "^3.13.1", "kind-of": "^6.0.2", "section-matter": "^1.0.0", "strip-bom-string": "^1.0.0" } }, "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q=="],
-
     "groq-sdk": ["groq-sdk@0.15.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" } }, "sha512-aYDEdr4qczx3cLCRRe+Beb37I7g/9bD5kHF+EEDxcrREWw1vKoRcfP3vHEkJB7Ud/8oOuF0scRwDpwWostTWuQ=="],
 
     "gtoken": ["gtoken@7.1.0", "", { "dependencies": { "gaxios": "^6.0.0", "jws": "^4.0.0" } }, "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw=="],
@@ -2038,7 +2051,7 @@
 
     "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="],
 
-    "import-in-the-middle": ["import-in-the-middle@1.14.0", "", { "dependencies": { "acorn": "^8.14.0", "acorn-import-attributes": "^1.9.5", "cjs-module-lexer": "^1.2.2", "module-details-from-path": "^1.0.3" } }, "sha512-g5zLT0HaztRJWysayWYiUq/7E5H825QIiecMD2pI5QO7Wzr847l6GDvPvmZaDIdrDtS2w7qRczywxiK6SL5vRw=="],
+    "import-in-the-middle": ["import-in-the-middle@1.14.2", "", { "dependencies": { "acorn": "^8.14.0", "acorn-import-attributes": "^1.9.5", "cjs-module-lexer": "^1.2.2", "module-details-from-path": "^1.0.3" } }, "sha512-5tCuY9BV8ujfOpwtAGgsTx9CGUapcFMEEyByLv1B+v2+6DhAcw+Zr0nhQT7uwaZ7DiourxFEscghOR8e1aPLQw=="],
 
     "indent-string": ["indent-string@4.0.0", "", {}, "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg=="],
 
@@ -2066,8 +2079,6 @@
 
     "is-decimal": ["is-decimal@2.0.1", "", {}, "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A=="],
 
-    "is-extendable": ["is-extendable@0.1.1", "", {}, "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw=="],
-
     "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
 
     "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
@@ -2152,8 +2163,6 @@
 
     "jwt-decode": ["jwt-decode@4.0.0", "", {}, "sha512-+KJGIyHgkGuIq3IEBNftfhW/LfWhXUIY6OmyVWjliu5KH1y0fw7VQ8YndE2O4qZdMSd9SqbnC8GOcZEy0Om7sA=="],
 
-    "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="],
-
     "kysely": ["kysely@0.28.2", "", {}, "sha512-4YAVLoF0Sf0UTqlhgQMFU9iQECdah7n+13ANkiuVfRvlK+uI0Etbgd7bVP36dKlG+NXWbhGua8vnGt+sdhvT7A=="],
 
     "leac": ["leac@0.6.0", "", {}, "sha512-y+SqErxb8h7nE/fiEX07jsbuhrpO9lL8eca7/Y1nuWV2moNlXhyd59iDGcRf6moVyDMbmTNzL40SUyrFU/yDpg=="],
@@ -2220,7 +2229,7 @@
 
     "lop": ["lop@0.4.2", "", { "dependencies": { "duck": "^0.1.12", "option": "~0.2.1", "underscore": "^1.13.1" } }, "sha512-RefILVDQ4DKoRZsJ4Pj22TxE3omDO47yFpkIBoDKzkqPRISs5U1cnAdg/5583YPkWPaLIYHOKRMQSvjFsO26cw=="],
 
-    "loupe": ["loupe@3.1.3", "", {}, "sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug=="],
+    "loupe": ["loupe@3.1.4", "", {}, "sha512-wJzkKwJrheKtknCOKNEtDK4iqg/MxmZheEMtSTYvnzRdEYaZzmgH976nenp8WdJRdx5Vc1X/9MO0Oszl6ezeXg=="],
 
     "lower-case": ["lower-case@2.0.2", "", { "dependencies": { "tslib": "^2.0.3" } }, "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg=="],
 
@@ -2380,9 +2389,9 @@
 
     "module-details-from-path": ["module-details-from-path@1.0.4", "", {}, "sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w=="],
 
-    "motion-dom": ["motion-dom@12.15.0", "", { "dependencies": { "motion-utils": "^12.12.1" } }, "sha512-D2ldJgor+2vdcrDtKJw48k3OddXiZN1dDLLWrS8kiHzQdYVruh0IoTwbJBslrnTXIPgFED7PBN2Zbwl7rNqnhA=="],
+    "motion-dom": ["motion-dom@12.18.1", "", { "dependencies": { "motion-utils": "^12.18.1" } }, "sha512-dR/4EYT23Snd+eUSLrde63Ws3oXQtJNw/krgautvTfwrN/2cHfCZMdu6CeTxVfRRWREW3Fy1f5vobRDiBb/q+w=="],
 
-    "motion-utils": ["motion-utils@12.12.1", "", {}, "sha512-f9qiqUHm7hWSLlNW8gS9pisnsN7CRFRD58vNjptKdsqFLpkVnX00TNeD6Q0d27V9KzT7ySFyK1TZ/DShfVOv6w=="],
+    "motion-utils": ["motion-utils@12.18.1", "", {}, "sha512-az26YDU4WoDP0ueAkUtABLk2BIxe28d8NH1qWT8jPGhPyf44XTdDUh8pDk9OPphaSrR9McgpcJlgwSOIw/sfkA=="],
 
     "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
 
@@ -2400,7 +2409,7 @@
 
     "neo-async": ["neo-async@2.6.2", "", {}, "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw=="],
 
-    "next": ["next@15.3.3", "", { "dependencies": { "@next/env": "15.3.3", "@swc/counter": "0.1.3", "@swc/helpers": "0.5.15", "busboy": "1.6.0", "caniuse-lite": "^1.0.30001579", "postcss": "8.4.31", "styled-jsx": "5.1.6" }, "optionalDependencies": { "@next/swc-darwin-arm64": "15.3.3", "@next/swc-darwin-x64": "15.3.3", "@next/swc-linux-arm64-gnu": "15.3.3", "@next/swc-linux-arm64-musl": "15.3.3", "@next/swc-linux-x64-gnu": "15.3.3", "@next/swc-linux-x64-musl": "15.3.3", "@next/swc-win32-arm64-msvc": "15.3.3", "@next/swc-win32-x64-msvc": "15.3.3", "sharp": "^0.34.1" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0", "@playwright/test": "^1.41.2", "babel-plugin-react-compiler": "*", "react": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "react-dom": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "sass": "^1.3.0" }, "optionalPeers": ["@opentelemetry/api", "@playwright/test", "babel-plugin-react-compiler", "sass"], "bin": { "next": "dist/bin/next" } }, "sha512-JqNj29hHNmCLtNvd090SyRbXJiivQ+58XjCcrC50Crb5g5u2zi7Y2YivbsEfzk6AtVI80akdOQbaMZwWB1Hthw=="],
+    "next": ["next@15.3.4", "", { "dependencies": { "@next/env": "15.3.4", "@swc/counter": "0.1.3", "@swc/helpers": "0.5.15", "busboy": "1.6.0", "caniuse-lite": "^1.0.30001579", "postcss": "8.4.31", "styled-jsx": "5.1.6" }, "optionalDependencies": { "@next/swc-darwin-arm64": "15.3.4", "@next/swc-darwin-x64": "15.3.4", "@next/swc-linux-arm64-gnu": "15.3.4", "@next/swc-linux-arm64-musl": "15.3.4", "@next/swc-linux-x64-gnu": "15.3.4", "@next/swc-linux-x64-musl": "15.3.4", "@next/swc-win32-arm64-msvc": "15.3.4", "@next/swc-win32-x64-msvc": "15.3.4", "sharp": "^0.34.1" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0", "@playwright/test": "^1.41.2", "babel-plugin-react-compiler": "*", "react": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "react-dom": "^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0", "sass": "^1.3.0" }, "optionalPeers": ["@opentelemetry/api", "@playwright/test", "babel-plugin-react-compiler", "sass"], "bin": { "next": "dist/bin/next" } }, "sha512-mHKd50C+mCjam/gcnwqL1T1vPx/XQNFlXqFIVdgQdVAFY9iIQtY0IfaVflEYzKiqjeA7B0cYYMaCrmAYFjs4rA=="],
 
     "next-runtime-env": ["next-runtime-env@3.3.0", "", { "dependencies": { "next": "^14", "react": "^18" } }, "sha512-JgKVnog9mNbjbjH9csVpMnz2tB2cT5sLF+7O47i6Ze/s/GoiKdV7dHhJHk1gwXpo6h5qPj5PTzryldtSjvrHuQ=="],
 
@@ -2504,7 +2513,7 @@
 
     "pg-int8": ["pg-int8@1.0.1", "", {}, "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw=="],
 
-    "pg-protocol": ["pg-protocol@1.10.0", "", {}, "sha512-IpdytjudNuLv8nhlHs/UrVBhU0e78J0oIS/0AVdTbWxSOkFUVdsHC/NrorO6nXsQNDTT1kzDSOMJubBQviX18Q=="],
+    "pg-protocol": ["pg-protocol@1.10.2", "", {}, "sha512-Ci7jy8PbaWxfsck2dwZdERcDG2A0MG8JoQILs+uZNjABFuBuItAZCWUNz8sXRDMoui24rJw7WlXqgpMdBSN/vQ=="],
 
     "pg-types": ["pg-types@2.2.0", "", { "dependencies": { "pg-int8": "1.0.1", "postgres-array": "~2.0.0", "postgres-bytea": "~1.0.0", "postgres-date": "~1.0.4", "postgres-interval": "^1.1.0" } }, "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA=="],
 
@@ -2526,11 +2535,11 @@
 
     "pirates": ["pirates@4.0.7", "", {}, "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA=="],
 
-    "playwright": ["playwright@1.52.0", "", { "dependencies": { "playwright-core": "1.52.0" }, "optionalDependencies": { "fsevents": "2.3.2" }, "bin": { "playwright": "cli.js" } }, "sha512-JAwMNMBlxJ2oD1kce4KPtMkDeKGHQstdpFPcPH3maElAXon/QZeTvtsfXmTMRyO9TslfoYOXkSsvao2nE1ilTw=="],
+    "playwright": ["playwright@1.53.1", "", { "dependencies": { "playwright-core": "1.53.1" }, "optionalDependencies": { "fsevents": "2.3.2" }, "bin": { "playwright": "cli.js" } }, "sha512-LJ13YLr/ocweuwxyGf1XNFWIU4M2zUSo149Qbp+A4cpwDjsxRPj7k6H25LBrEHiEwxvRbD8HdwvQmRMSvquhYw=="],
 
-    "playwright-core": ["playwright-core@1.52.0", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-l2osTgLXSMeuLZOML9qYODUQoPPnUsKsb5/P6LJ2e6uPKXUdPK5WYhN4z03G+YNbWmGDY4YENauNu4ZKczreHg=="],
+    "playwright-core": ["playwright-core@1.53.1", "", { "bin": { "playwright-core": "cli.js" } }, "sha512-Z46Oq7tLAyT0lGoFx4DOuB1IA9D1TPj0QkYxpPVUnGDqHHvDpCftu1J2hM2PiWsNMoZh8+LQaarAWcDfPBc6zg=="],
 
-    "postcss": ["postcss@8.5.4", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w=="],
+    "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="],
 
     "postcss-import": ["postcss-import@15.1.0", "", { "dependencies": { "postcss-value-parser": "^4.0.0", "read-cache": "^1.0.0", "resolve": "^1.1.7" }, "peerDependencies": { "postcss": "^8.0.0" } }, "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew=="],
 
@@ -2558,7 +2567,7 @@
 
     "prettier": ["prettier@3.5.3", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw=="],
 
-    "prettier-plugin-tailwindcss": ["prettier-plugin-tailwindcss@0.6.12", "", { "peerDependencies": { "@ianvs/prettier-plugin-sort-imports": "*", "@prettier/plugin-pug": "*", "@shopify/prettier-plugin-liquid": "*", "@trivago/prettier-plugin-sort-imports": "*", "@zackad/prettier-plugin-twig": "*", "prettier": "^3.0", "prettier-plugin-astro": "*", "prettier-plugin-css-order": "*", "prettier-plugin-import-sort": "*", "prettier-plugin-jsdoc": "*", "prettier-plugin-marko": "*", "prettier-plugin-multiline-arrays": "*", "prettier-plugin-organize-attributes": "*", "prettier-plugin-organize-imports": "*", "prettier-plugin-sort-imports": "*", "prettier-plugin-style-order": "*", "prettier-plugin-svelte": "*" }, "optionalPeers": ["@ianvs/prettier-plugin-sort-imports", "@prettier/plugin-pug", "@shopify/prettier-plugin-liquid", "@trivago/prettier-plugin-sort-imports", "@zackad/prettier-plugin-twig", "prettier-plugin-astro", "prettier-plugin-css-order", "prettier-plugin-import-sort", "prettier-plugin-jsdoc", "prettier-plugin-marko", "prettier-plugin-multiline-arrays", "prettier-plugin-organize-attributes", "prettier-plugin-organize-imports", "prettier-plugin-sort-imports", "prettier-plugin-style-order", "prettier-plugin-svelte"] }, "sha512-OuTQKoqNwV7RnxTPwXWzOFXy6Jc4z8oeRZYGuMpRyG3WbuR3jjXdQFK8qFBMBx8UHWdHrddARz2fgUenild6aw=="],
+    "prettier-plugin-tailwindcss": ["prettier-plugin-tailwindcss@0.6.13", "", { "peerDependencies": { "@ianvs/prettier-plugin-sort-imports": "*", "@prettier/plugin-pug": "*", "@shopify/prettier-plugin-liquid": "*", "@trivago/prettier-plugin-sort-imports": "*", "@zackad/prettier-plugin-twig": "*", "prettier": "^3.0", "prettier-plugin-astro": "*", "prettier-plugin-css-order": "*", "prettier-plugin-import-sort": "*", "prettier-plugin-jsdoc": "*", "prettier-plugin-marko": "*", "prettier-plugin-multiline-arrays": "*", "prettier-plugin-organize-attributes": "*", "prettier-plugin-organize-imports": "*", "prettier-plugin-sort-imports": "*", "prettier-plugin-style-order": "*", "prettier-plugin-svelte": "*" }, "optionalPeers": ["@ianvs/prettier-plugin-sort-imports", "@prettier/plugin-pug", "@shopify/prettier-plugin-liquid", "@trivago/prettier-plugin-sort-imports", "@zackad/prettier-plugin-twig", "prettier-plugin-astro", "prettier-plugin-css-order", "prettier-plugin-import-sort", "prettier-plugin-jsdoc", "prettier-plugin-marko", "prettier-plugin-multiline-arrays", "prettier-plugin-organize-attributes", "prettier-plugin-organize-imports", "prettier-plugin-sort-imports", "prettier-plugin-style-order", "prettier-plugin-svelte"] }, "sha512-uQ0asli1+ic8xrrSmIOaElDu0FacR4x69GynTh2oZjFY10JUt6EEumTQl5tB4fMeD6I1naKd+4rXQQ7esT2i1g=="],
 
     "pretty-format": ["pretty-format@27.5.1", "", { "dependencies": { "ansi-regex": "^5.0.1", "ansi-styles": "^5.0.0", "react-is": "^17.0.1" } }, "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ=="],
 
@@ -2580,7 +2589,7 @@
 
     "proxy-from-env": ["proxy-from-env@1.1.0", "", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="],
 
-    "pump": ["pump@3.0.2", "", { "dependencies": { "end-of-stream": "^1.1.0", "once": "^1.3.1" } }, "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw=="],
+    "pump": ["pump@3.0.3", "", { "dependencies": { "end-of-stream": "^1.1.0", "once": "^1.3.1" } }, "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA=="],
 
     "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="],
 
@@ -2604,11 +2613,11 @@
 
     "react-dom": ["react-dom@19.1.0", "", { "dependencies": { "scheduler": "^0.26.0" }, "peerDependencies": { "react": "^19.1.0" } }, "sha512-Xs1hdnE+DyKgeHJeJznQmYMIBG3TKIHJJT95Q58nHLSrElKlGQqDTR2HQ9fx5CN/Gk6Vh/kupBTDLU11/nDk/g=="],
 
-    "react-email": ["react-email@4.0.15", "", { "dependencies": { "@babel/parser": "^7.27.0", "@babel/traverse": "^7.27.0", "chalk": "^5.0.0", "chokidar": "^4.0.3", "commander": "^13.0.0", "debounce": "^2.0.0", "esbuild": "^0.25.0", "glob": "^11.0.0", "log-symbols": "^7.0.0", "mime-types": "^3.0.0", "next": "^15.3.1", "normalize-path": "^3.0.0", "ora": "^8.0.0", "socket.io": "^4.8.1" }, "bin": { "email": "dist/cli/index.mjs" } }, "sha512-UQR18Toi3TAasqcZal69rYZ9RiIKRvHRW69tN6k7hONJpEPeiC4uBtDwH5VxpllW591D+NOdpBF/V1pTansaKg=="],
+    "react-email": ["react-email@4.0.16", "", { "dependencies": { "@babel/parser": "^7.27.0", "@babel/traverse": "^7.27.0", "chalk": "^5.0.0", "chokidar": "^4.0.3", "commander": "^13.0.0", "debounce": "^2.0.0", "esbuild": "^0.25.0", "glob": "^11.0.0", "log-symbols": "^7.0.0", "mime-types": "^3.0.0", "next": "^15.3.1", "normalize-path": "^3.0.0", "ora": "^8.0.0", "socket.io": "^4.8.1" }, "bin": { "email": "dist/cli/index.mjs" } }, "sha512-auhFU+nQxAkKkP6lQhPyGsa9exwfUEzp2BwZnjHokCwphZlg30tu4t1LgdKRwGPYsi7XNGy6asbVLAUhOVpzzg=="],
 
     "react-google-drive-picker": ["react-google-drive-picker@1.2.2", "", { "peerDependencies": { "react": ">=17.0.0", "react-dom": ">=17.0.0" } }, "sha512-x30mYkt9MIwPCgL+fyK75HZ8E6G5L/WGW0bfMG6kbD4NG2kmdlmV9oH5lPa6P6d46y9hj5Y3btAMrZd4JRRkSA=="],
 
-    "react-hook-form": ["react-hook-form@7.57.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17 || ^18 || ^19" } }, "sha512-RbEks3+cbvTP84l/VXGUZ+JMrKOS8ykQCRYdm5aYsxnDquL0vspsyNhGRO7pcH6hsZqWlPOjLye7rJqdtdAmlg=="],
+    "react-hook-form": ["react-hook-form@7.58.1", "", { "peerDependencies": { "react": "^16.8.0 || ^17 || ^18 || ^19" } }, "sha512-Lml/KZYEEFfPhUVgE0RdCVpnC4yhW+PndRhbiTtdvSlQTL8IfVR+iQkBjLIvmmc6+GGoVeM11z37ktKFPAb0FA=="],
 
     "react-is": ["react-is@18.3.1", "", {}, "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg=="],
 
@@ -2688,7 +2697,7 @@
 
     "requires-port": ["requires-port@1.0.0", "", {}, "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ=="],
 
-    "resend": ["resend@4.5.1", "", { "dependencies": { "@react-email/render": "1.0.6" } }, "sha512-ryhHpZqCBmuVyzM19IO8Egtc2hkWI4JOL5lf5F3P7Dydu3rFeX6lHNpGqG0tjWoZ63rw0l731JEmuJZBdDm3og=="],
+    "resend": ["resend@4.6.0", "", { "dependencies": { "@react-email/render": "1.1.2" } }, "sha512-D5T2I82FvEUYFlrHzaDvVtr5ADHdhuoLaXgLFGABKyNtQgPWIuz0Vp2L2Evx779qjK37aF4kcw1yXJDHhA2JnQ=="],
 
     "resolve": ["resolve@1.22.10", "", { "dependencies": { "is-core-module": "^2.16.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w=="],
 
@@ -2730,8 +2739,6 @@
 
     "scroll-into-view-if-needed": ["scroll-into-view-if-needed@3.1.0", "", { "dependencies": { "compute-scroll-into-view": "^3.0.2" } }, "sha512-49oNpRjWRvnU8NyGVmUaYG4jtTkNonFZI86MmGRDqBphEK2EXT9gdEUoQPZhuBM8yWHxCWbobltqYO5M4XrUvQ=="],
 
-    "section-matter": ["section-matter@1.0.0", "", { "dependencies": { "extend-shallow": "^2.0.1", "kind-of": "^6.0.0" } }, "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA=="],
-
     "secure-json-parse": ["secure-json-parse@2.7.0", "", {}, "sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw=="],
 
     "selderee": ["selderee@0.11.0", "", { "dependencies": { "parseley": "^0.12.0" } }, "sha512-5TF+l7p4+OsnP8BCCvSyZiSPc4x4//p5uPwK8TCnVPJYRmU2aYKMpOXvw8zM5a5JvuuCGN1jmsMwuU2W02ukfA=="],
@@ -2752,7 +2759,9 @@
 
     "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
 
-    "shiki": ["shiki@3.4.2", "", { "dependencies": { "@shikijs/core": "3.4.2", "@shikijs/engine-javascript": "3.4.2", "@shikijs/engine-oniguruma": "3.4.2", "@shikijs/langs": "3.4.2", "@shikijs/themes": "3.4.2", "@shikijs/types": "3.4.2", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-wuxzZzQG8kvZndD7nustrNFIKYJ1jJoWIPaBpVe2+KHSvtzMi4SBjOxrigs8qeqce/l3U0cwiC+VAkLKSunHQQ=="],
+    "shell-quote": ["shell-quote@1.8.3", "", {}, "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw=="],
+
+    "shiki": ["shiki@3.7.0", "", { "dependencies": { "@shikijs/core": "3.7.0", "@shikijs/engine-javascript": "3.7.0", "@shikijs/engine-oniguruma": "3.7.0", "@shikijs/langs": "3.7.0", "@shikijs/themes": "3.7.0", "@shikijs/types": "3.7.0", "@shikijs/vscode-textmate": "^10.0.2", "@types/hast": "^3.0.4" } }, "sha512-ZcI4UT9n6N2pDuM2n3Jbk0sR4Swzq43nLPgS/4h0E3B/NrFn2HKElrDtceSf8Zx/OWYOo7G1SAtBLypCp+YXqg=="],
 
     "shimmer": ["shimmer@1.2.1", "", {}, "sha512-sQTKC1Re/rM6XyFM6fIAGHRPVGvyXfgzIDvzoq608vM+jeyVD0Tu1E6Np0Kc2zAIFWIj963V2800iF/9LPieQw=="],
 
@@ -2784,6 +2793,8 @@
 
     "socket.io-adapter": ["socket.io-adapter@2.5.5", "", { "dependencies": { "debug": "~4.3.4", "ws": "~8.17.1" } }, "sha512-eLDQas5dzPgOWCk9GuuJC2lBqItuhKI4uxGgo9aIV7MYbk2h9Q6uULEh8WBzThoI7l+qU9Ast9fVUmkqPP9wYg=="],
 
+    "socket.io-client": ["socket.io-client@4.8.1", "", { "dependencies": { "@socket.io/component-emitter": "~3.1.0", "debug": "~4.3.2", "engine.io-client": "~6.6.1", "socket.io-parser": "~4.2.4" } }, "sha512-hJVXfu3E28NmzGk8o1sHhN3om52tRvwYeidbj7xKy2eIIse5IoKX3USlS6Tqt3BHAtflLIkCQBkzVrEEfWUyYQ=="],
+
     "socket.io-parser": ["socket.io-parser@4.2.4", "", { "dependencies": { "@socket.io/component-emitter": "~3.1.0", "debug": "~4.3.1" } }, "sha512-/GbIKmo8ioc+NIWIhwdecY0ge+qVBSMdgxGygevmdHj24bsfgtCmcUUcQ5ZzcylGFHsN3k4HB4Cgkl96KVnuew=="],
 
     "sonic-boom": ["sonic-boom@4.2.0", "", { "dependencies": { "atomic-sleep": "^1.0.0" } }, "sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww=="],
@@ -2832,25 +2843,25 @@
 
     "strip-ansi-cjs": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
 
-    "strip-bom-string": ["strip-bom-string@1.0.0", "", {}, "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g=="],
-
     "strip-indent": ["strip-indent@3.0.0", "", { "dependencies": { "min-indent": "^1.0.0" } }, "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ=="],
 
     "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="],
 
+    "strip-literal": ["strip-literal@3.0.0", "", { "dependencies": { "js-tokens": "^9.0.1" } }, "sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA=="],
+
     "stripe": ["stripe@17.7.0", "", { "dependencies": { "@types/node": ">=8.1.0", "qs": "^6.11.0" } }, "sha512-aT2BU9KkizY9SATf14WhhYVv2uOapBWX0OFWF4xvcj1mPaNotlSc2CsxpS4DS46ZueSppmCF5BX1sNYBtwBvfw=="],
 
     "strnum": ["strnum@1.1.2", "", {}, "sha512-vrN+B7DBIoTTZjnPNewwhx6cBA/H+IS7rfW68n7XxC1y7uoiGQBxaKzqucGUgavX15dJgiGztLJ8vxuEzwqBdA=="],
 
-    "style-to-js": ["style-to-js@1.1.16", "", { "dependencies": { "style-to-object": "1.0.8" } }, "sha512-/Q6ld50hKYPH3d/r6nr117TZkHR0w0kGGIVfpG9N6D8NymRPM9RqCUv4pRpJ62E5DqOYx2AFpbZMyCPnjQCnOw=="],
+    "style-to-js": ["style-to-js@1.1.17", "", { "dependencies": { "style-to-object": "1.0.9" } }, "sha512-xQcBGDxJb6jjFCTzvQtfiPn6YvvP2O8U1MDIPNfJQlWMYfktPy+iGsHE7cssjs7y84d9fQaK4UF3RIJaAHSoYA=="],
 
-    "style-to-object": ["style-to-object@1.0.8", "", { "dependencies": { "inline-style-parser": "0.2.4" } }, "sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g=="],
+    "style-to-object": ["style-to-object@1.0.9", "", { "dependencies": { "inline-style-parser": "0.2.4" } }, "sha512-G4qppLgKu/k6FwRpHiGiKPaPTFcG3g4wNVX/Qsfu+RqQM30E7Tyu/TEgxcL9PNLF5pdRLwQdE3YKKf+KF2Dzlw=="],
 
     "styled-jsx": ["styled-jsx@5.1.6", "", { "dependencies": { "client-only": "0.0.1" }, "peerDependencies": { "react": ">= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0" } }, "sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA=="],
 
     "sucrase": ["sucrase@3.35.0", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.2", "commander": "^4.0.0", "glob": "^10.3.10", "lines-and-columns": "^1.1.6", "mz": "^2.7.0", "pirates": "^4.0.1", "ts-interface-checker": "^0.1.9" }, "bin": { "sucrase": "bin/sucrase", "sucrase-node": "bin/sucrase-node" } }, "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA=="],
 
-    "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+    "supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
 
     "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="],
 
@@ -2858,7 +2869,7 @@
 
     "symbol-tree": ["symbol-tree@3.2.4", "", {}, "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw=="],
 
-    "tailwind-merge": ["tailwind-merge@3.3.0", "", {}, "sha512-fyW/pEfcQSiigd5SNn0nApUOxx0zB/dm6UDU/rEwc2c3sX2smWUNbapHv+QRqLGVp9GWX3THIa7MUGPo+YkDzQ=="],
+    "tailwind-merge": ["tailwind-merge@3.3.1", "", {}, "sha512-gBXpgUm/3rp1lMZZrM/w7D8GKqshif0zAymAhbCyIt8KMe+0v9DQ7cdYLR4FHH/cKpdTXb+A/tKKU3eolfsI+g=="],
 
     "tailwindcss": ["tailwindcss@3.4.1", "", { "dependencies": { "@alloc/quick-lru": "^5.2.0", "arg": "^5.0.2", "chokidar": "^3.5.3", "didyoumean": "^1.2.2", "dlv": "^1.1.3", "fast-glob": "^3.3.0", "glob-parent": "^6.0.2", "is-glob": "^4.0.3", "jiti": "^1.19.1", "lilconfig": "^2.1.0", "micromatch": "^4.0.5", "normalize-path": "^3.0.0", "object-hash": "^3.0.0", "picocolors": "^1.0.0", "postcss": "^8.4.23", "postcss-import": "^15.1.0", "postcss-js": "^4.0.1", "postcss-load-config": "^4.0.1", "postcss-nested": "^6.0.1", "postcss-selector-parser": "^6.0.11", "resolve": "^1.22.2", "sucrase": "^3.32.0" }, "bin": { "tailwind": "lib/cli.js", "tailwindcss": "lib/cli.js" } }, "sha512-qAYmXRfk3ENzuPBakNK0SRrUDipP8NQnEY6772uDhflcQz5EhRdD7JNZxyrFHVQNCwULPBn6FNPp9brpO7ctcA=="],
 
@@ -2868,7 +2879,7 @@
 
     "tar": ["tar@7.4.3", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.0.1", "mkdirp": "^3.0.1", "yallist": "^5.0.0" } }, "sha512-5S7Va8hKfV7W5U6g3aYxXmlPoZVAwUMy9AOKyF2fVuZa2UD3qZjg578OrLRt8PcNN1PleVaL/5/yYATNL0ICUw=="],
 
-    "terser": ["terser@5.40.0", "", { "dependencies": { "@jridgewell/source-map": "^0.3.3", "acorn": "^8.14.0", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, "bin": { "terser": "bin/terser" } }, "sha512-cfeKl/jjwSR5ar7d0FGmave9hFGJT8obyo0z+CrQOylLDbk7X81nPU6vq9VORa5jU30SkDnT2FXjLbR8HLP+xA=="],
+    "terser": ["terser@5.43.1", "", { "dependencies": { "@jridgewell/source-map": "^0.3.3", "acorn": "^8.14.0", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, "bin": { "terser": "bin/terser" } }, "sha512-+6erLbBm0+LROX2sPXlUYx/ux5PyE9K/a92Wrt6oA+WDAoFTdpHE5tCYCI5PNzq2y8df4rA+QgHLJuR4jNymsg=="],
 
     "terser-webpack-plugin": ["terser-webpack-plugin@5.3.14", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.25", "jest-worker": "^27.4.5", "schema-utils": "^4.3.0", "serialize-javascript": "^6.0.2", "terser": "^5.31.1" }, "peerDependencies": { "webpack": "^5.1.0" } }, "sha512-vkZjpUjb6OMS7dhV+tILUW6BhpDR7P2L/aQSAv+Uwk+m8KATX9EccViHTJR2qDtACKPIYndLGCyl3FMo+r2LMw=="],
 
@@ -2898,7 +2909,7 @@
 
     "tinyglobby": ["tinyglobby@0.2.14", "", { "dependencies": { "fdir": "^6.4.4", "picomatch": "^4.0.2" } }, "sha512-tX5e7OM1HnYr2+a2C/4V0htOcSQcoSTH9KgJnVvNm5zm/cyEWKJ7j7YutsH9CxMdtOkkLFy2AHrMci9IM8IPZQ=="],
 
-    "tinypool": ["tinypool@1.1.0", "", {}, "sha512-7CotroY9a8DKsKprEy/a14aCCm8jYVmR7aFy4fpkZM8sdpNJbKkixuNjgM50yCmip2ezc8z4N7k3oe2+rfRJCQ=="],
+    "tinypool": ["tinypool@1.1.1", "", {}, "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg=="],
 
     "tinyrainbow": ["tinyrainbow@2.0.0", "", {}, "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw=="],
 
@@ -2916,6 +2927,8 @@
 
     "tr46": ["tr46@5.1.1", "", { "dependencies": { "punycode": "^2.3.1" } }, "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw=="],
 
+    "tree-kill": ["tree-kill@1.2.2", "", { "bin": { "tree-kill": "cli.js" } }, "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A=="],
+
     "trim-lines": ["trim-lines@3.0.1", "", {}, "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg=="],
 
     "trough": ["trough@2.2.0", "", {}, "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw=="],
@@ -3000,11 +3013,11 @@
 
     "vite": ["vite@6.3.5", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.4", "picomatch": "^4.0.2", "postcss": "^8.5.3", "rollup": "^4.34.9", "tinyglobby": "^0.2.13" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "jiti": ">=1.21.0", "less": "*", "lightningcss": "^1.21.0", "sass": "*", "sass-embedded": "*", "stylus": "*", "sugarss": "*", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ=="],
 
-    "vite-node": ["vite-node@3.2.0", "", { "dependencies": { "cac": "^6.7.14", "debug": "^4.4.1", "es-module-lexer": "^1.7.0", "pathe": "^2.0.3", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "bin": { "vite-node": "vite-node.mjs" } }, "sha512-8Fc5Ko5Y4URIJkmMF/iFP1C0/OJyY+VGVe9Nw6WAdZyw4bTO+eVg9mwxWkQp/y8NnAoQY3o9KAvE1ZdA2v+Vmg=="],
+    "vite-node": ["vite-node@3.2.4", "", { "dependencies": { "cac": "^6.7.14", "debug": "^4.4.1", "es-module-lexer": "^1.7.0", "pathe": "^2.0.3", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "bin": { "vite-node": "vite-node.mjs" } }, "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg=="],
 
     "vite-tsconfig-paths": ["vite-tsconfig-paths@5.1.4", "", { "dependencies": { "debug": "^4.1.1", "globrex": "^0.1.2", "tsconfck": "^3.0.3" }, "peerDependencies": { "vite": "*" }, "optionalPeers": ["vite"] }, "sha512-cYj0LRuLV2c2sMqhqhGpaO3LretdtMn/BVX4cPLanIZuwwrkVl+lK84E/miEXkCHWXuq65rhNN4rXsBcOB3S4w=="],
 
-    "vitest": ["vitest@3.2.0", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/expect": "3.2.0", "@vitest/mocker": "3.2.0", "@vitest/pretty-format": "^3.2.0", "@vitest/runner": "3.2.0", "@vitest/snapshot": "3.2.0", "@vitest/spy": "3.2.0", "@vitest/utils": "3.2.0", "chai": "^5.2.0", "debug": "^4.4.1", "expect-type": "^1.2.1", "magic-string": "^0.30.17", "pathe": "^2.0.3", "picomatch": "^4.0.2", "std-env": "^3.9.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.14", "tinypool": "^1.1.0", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", "vite-node": "3.2.0", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.2.0", "@vitest/ui": "3.2.0", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-P7Nvwuli8WBNmeMHHek7PnGW4oAZl9za1fddfRVidZar8wDZRi7hpznLKQePQ8JPLwSBEYDK11g+++j7uFJV8Q=="],
+    "vitest": ["vitest@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/expect": "3.2.4", "@vitest/mocker": "3.2.4", "@vitest/pretty-format": "^3.2.4", "@vitest/runner": "3.2.4", "@vitest/snapshot": "3.2.4", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "debug": "^4.4.1", "expect-type": "^1.2.1", "magic-string": "^0.30.17", "pathe": "^2.0.3", "picomatch": "^4.0.2", "std-env": "^3.9.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.14", "tinypool": "^1.1.1", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", "vite-node": "3.2.4", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.2.4", "@vitest/ui": "3.2.4", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "vitest.mjs" } }, "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A=="],
 
     "w3c-xmlserializer": ["w3c-xmlserializer@5.0.0", "", { "dependencies": { "xml-name-validator": "^5.0.0" } }, "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA=="],
 
@@ -3018,7 +3031,7 @@
 
     "webpack": ["webpack@5.99.9", "", { "dependencies": { "@types/eslint-scope": "^3.7.7", "@types/estree": "^1.0.6", "@types/json-schema": "^7.0.15", "@webassemblyjs/ast": "^1.14.1", "@webassemblyjs/wasm-edit": "^1.14.1", "@webassemblyjs/wasm-parser": "^1.14.1", "acorn": "^8.14.0", "browserslist": "^4.24.0", "chrome-trace-event": "^1.0.2", "enhanced-resolve": "^5.17.1", "es-module-lexer": "^1.2.1", "eslint-scope": "5.1.1", "events": "^3.2.0", "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.2.11", "json-parse-even-better-errors": "^2.3.1", "loader-runner": "^4.2.0", "mime-types": "^2.1.27", "neo-async": "^2.6.2", "schema-utils": "^4.3.2", "tapable": "^2.1.1", "terser-webpack-plugin": "^5.3.11", "watchpack": "^2.4.1", "webpack-sources": "^3.2.3" }, "bin": { "webpack": "bin/webpack.js" } }, "sha512-brOPwM3JnmOa+7kd3NsmOUOwbDAj8FT9xDsG3IW0MgbN9yZV7Oi/s/+MNQ/EcSMqw7qfoRyXPoeEWT8zLVdVGg=="],
 
-    "webpack-sources": ["webpack-sources@3.3.2", "", {}, "sha512-ykKKus8lqlgXX/1WjudpIEjqsafjOTcOJqxnAbMLAu/KCsDCJ6GBtvscewvTkrn24HsnvFwrSCbenFrhtcCsAA=="],
+    "webpack-sources": ["webpack-sources@3.3.3", "", {}, "sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg=="],
 
     "webpack-virtual-modules": ["webpack-virtual-modules@0.5.0", "", {}, "sha512-kyDivFZ7ZM0BVOUteVbDFhlRt7Ah/CSPwJdi8hBpkK7QLumUqdLtVfm/PX/hkcnrvr0i77fO5+TjZ94Pe+C9iw=="],
 
@@ -3052,6 +3065,8 @@
 
     "xmlchars": ["xmlchars@2.2.0", "", {}, "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw=="],
 
+    "xmlhttprequest-ssl": ["xmlhttprequest-ssl@2.1.2", "", {}, "sha512-TEU+nJVUUnA4CYJFLvK5X9AOeH4KvDvhIfm0vV1GaQRtchnG0hgK5p8hw/xjv8cunWYCsiPCSDzObPyhEwq3KQ=="],
+
     "xorshift": ["xorshift@1.2.0", "", {}, "sha512-iYgNnGyeeJ4t6U11NpA/QiKy+PXn5Aa3Azg5qkwIFz1tBLllQrjjsk9yzD7IAK0naNU4JxdeDgqW9ov4u/hc4g=="],
 
     "xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="],
@@ -3072,7 +3087,7 @@
 
     "yoga-wasm-web": ["yoga-wasm-web@0.3.3", "", {}, "sha512-N+d4UJSJbt/R3wqY7Coqs5pcV0aUj2j9IaQ3rNj9bVCLld8tTGKRa2USARjnvZJWVx1NDmQev8EknoczaOQDOA=="],
 
-    "zod": ["zod@3.25.48", "", {}, "sha512-0X1mz8FtgEIvaxGjdIImYpZEaZMrund9pGXm3M6vM7Reba0e2eI71KPjSCGXBfwKDPwPoywf6waUKc3/tFvX2Q=="],
+    "zod": ["zod@3.25.67", "", {}, "sha512-idA2YXwpCdqUSKRCACDE6ItZD9TZzy3OZMtpfLoh6oPR47lipysRrJfjzMqFxQ3uJuUPyUeWe1r9vLH33xO/Qw=="],
 
     "zod-to-json-schema": ["zod-to-json-schema@3.24.5", "", { "peerDependencies": { "zod": "^3.24.1" } }, "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g=="],
 
@@ -3082,7 +3097,7 @@
 
     "zwitch": ["zwitch@2.0.4", "", {}, "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A=="],
 
-    "@anthropic-ai/sdk/@types/node": ["@types/node@18.19.110", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-WW2o4gTmREtSnqKty9nhqF/vA0GKd0V/rbC0OyjSk9Bz6bzlsXKT+i7WDdS/a0z74rfT2PO4dArVCSnapNLA5Q=="],
+    "@anthropic-ai/sdk/@types/node": ["@types/node@18.19.112", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog=="],
 
     "@anthropic-ai/sdk/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
 
@@ -3094,6 +3109,8 @@
 
     "@aws-crypto/util/@smithy/util-utf8": ["@smithy/util-utf8@2.3.0", "", { "dependencies": { "@smithy/util-buffer-from": "^2.2.0", "tslib": "^2.6.2" } }, "sha512-R8Rdn8Hy72KKcebgLiv8jQcQkXoLMOGGv5uI1/k0l+snqkOzQ1R0ChUBCxWMlBsFMekWjq0wRudIweFs7sKT5A=="],
 
+    "@aws-sdk/client-s3/uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
+
     "@azure/core-xml/fast-xml-parser": ["fast-xml-parser@5.2.5", "", { "dependencies": { "strnum": "^2.1.0" }, "bin": { "fxparser": "src/cli/cli.js" } }, "sha512-pfX9uG9Ki0yekDHx2SiuRIyFdyAr1kMIMitPvb0YBo8SUfKvia7w7FIyd/l6av85pFYRhZscS75MwMnbvY+hcQ=="],
 
     "@babel/code-frame/js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="],
@@ -3104,11 +3121,11 @@
 
     "@babel/helper-compilation-targets/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="],
 
-    "@browserbasehq/sdk/@types/node": ["@types/node@18.19.110", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-WW2o4gTmREtSnqKty9nhqF/vA0GKd0V/rbC0OyjSk9Bz6bzlsXKT+i7WDdS/a0z74rfT2PO4dArVCSnapNLA5Q=="],
+    "@browserbasehq/sdk/@types/node": ["@types/node@18.19.112", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog=="],
 
     "@browserbasehq/sdk/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
 
-    "@cerebras/cerebras_cloud_sdk/@types/node": ["@types/node@18.19.110", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-WW2o4gTmREtSnqKty9nhqF/vA0GKd0V/rbC0OyjSk9Bz6bzlsXKT+i7WDdS/a0z74rfT2PO4dArVCSnapNLA5Q=="],
+    "@cerebras/cerebras_cloud_sdk/@types/node": ["@types/node@18.19.112", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog=="],
 
     "@cerebras/cerebras_cloud_sdk/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
 
@@ -3362,7 +3379,7 @@
 
     "@tailwindcss/oxide-wasm32-wasi/@emnapi/wasi-threads": ["@emnapi/wasi-threads@1.0.2", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-5n3nTJblwRi8LlXkJ9eBzu+kZR8Yxcc7ubakyQTFzPMtIhFpUBRbsnc2Dv88IZDIbCDlBiWrknhB4Lsz7mg6BA=="],
 
-    "@tailwindcss/oxide-wasm32-wasi/@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@0.2.10", "", { "dependencies": { "@emnapi/core": "^1.4.3", "@emnapi/runtime": "^1.4.3", "@tybys/wasm-util": "^0.9.0" }, "bundled": true }, "sha512-bCsCyeZEwVErsGmyPNSzwfwFn4OdxBj0mmv6hOFucB/k81Ojdu68RbZdxYsRQUPc9l6SU5F/cG+bXgWs3oUgsQ=="],
+    "@tailwindcss/oxide-wasm32-wasi/@napi-rs/wasm-runtime": ["@napi-rs/wasm-runtime@0.2.11", "", { "dependencies": { "@emnapi/core": "^1.4.3", "@emnapi/runtime": "^1.4.3", "@tybys/wasm-util": "^0.9.0" }, "bundled": true }, "sha512-9DPkXtvHydrcOsopiYpUgPHpmj0HWZKMUnL2dZqpvC42lsratuBG06V5ipyno0fUek5VlFsNQ+AcFATSrJXgMA=="],
 
     "@tailwindcss/oxide-wasm32-wasi/@tybys/wasm-util": ["@tybys/wasm-util@0.9.0", "", { "dependencies": { "tslib": "^2.4.0" }, "bundled": true }, "sha512-6+7nlbMVX/PVDCwaIQ8nTOPveOcFLSt8GcXdx8hD0bt39uWxYT88uXzqTd4fTvqta7oeUJqudepapKNt2DYJFw=="],
 
@@ -3390,6 +3407,8 @@
 
     "bl/readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
 
+    "chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
     "chokidar/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="],
 
     "cli-truncate/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
@@ -3400,12 +3419,14 @@
 
     "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
 
-    "ecdsa-sig-formatter/safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
-
     "engine.io/debug": ["debug@4.3.7", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ=="],
 
     "engine.io/ws": ["ws@8.17.1", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ=="],
 
+    "engine.io-client/debug": ["debug@4.3.7", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ=="],
+
+    "engine.io-client/ws": ["ws@8.17.1", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ=="],
+
     "error-ex/is-arrayish": ["is-arrayish@0.2.1", "", {}, "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="],
 
     "esrecurse/estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="],
@@ -3428,11 +3449,9 @@
 
     "gaxios/uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
 
-    "glob/minimatch": ["minimatch@10.0.1", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-ethXTt3SGGR+95gudmqJ1eNhRO7eGEGIgYA9vnPatK4/etz2MEVDno5GMCibdMTuBMyElzIlgxMna3K94XDIDQ=="],
+    "glob/minimatch": ["minimatch@10.0.3", "", { "dependencies": { "@isaacs/brace-expansion": "^5.0.0" } }, "sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw=="],
 
-    "gray-matter/js-yaml": ["js-yaml@3.14.1", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g=="],
-
-    "groq-sdk/@types/node": ["@types/node@18.19.110", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-WW2o4gTmREtSnqKty9nhqF/vA0GKd0V/rbC0OyjSk9Bz6bzlsXKT+i7WDdS/a0z74rfT2PO4dArVCSnapNLA5Q=="],
+    "groq-sdk/@types/node": ["@types/node@18.19.112", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog=="],
 
     "groq-sdk/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
 
@@ -3444,20 +3463,16 @@
 
     "isomorphic-unfetch/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
 
+    "istanbul-lib-report/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
     "jaeger-client/uuid": ["uuid@8.3.2", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="],
 
     "jest-diff/pretty-format": ["pretty-format@26.6.2", "", { "dependencies": { "@jest/types": "^26.6.2", "ansi-regex": "^5.0.0", "ansi-styles": "^4.0.0", "react-is": "^17.0.1" } }, "sha512-7AeGuCYNGmycyQbCqd/3PWH4eOoX/OiCa0uphp57NVTeAGdJGaAliecxwBDHYQCIvrW7aDBZCYeNTP/WX69mkg=="],
 
-    "jest-worker/supports-color": ["supports-color@8.1.1", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q=="],
-
     "js-yaml/argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
 
     "jsondiffpatch/chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="],
 
-    "jwa/safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
-
-    "jws/safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
-
     "linebreak/base64-js": ["base64-js@0.0.8", "", {}, "sha512-3XSA2cR/h/73EzlXXdU6YNycmYI7+kicTxks4eJg2g39biHR84slg2+des+p7iHYhbRg/udIS4TD53WabcOUkw=="],
 
     "lint-staged/chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="],
@@ -3486,9 +3501,9 @@
 
     "next/postcss": ["postcss@8.4.31", "", { "dependencies": { "nanoid": "^3.3.6", "picocolors": "^1.0.0", "source-map-js": "^1.0.2" } }, "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ=="],
 
-    "next-runtime-env/next": ["next@14.2.29", "", { "dependencies": { "@next/env": "14.2.29", "@swc/helpers": "0.5.5", "busboy": "1.6.0", "caniuse-lite": "^1.0.30001579", "graceful-fs": "^4.2.11", "postcss": "8.4.31", "styled-jsx": "5.1.1" }, "optionalDependencies": { "@next/swc-darwin-arm64": "14.2.29", "@next/swc-darwin-x64": "14.2.29", "@next/swc-linux-arm64-gnu": "14.2.29", "@next/swc-linux-arm64-musl": "14.2.29", "@next/swc-linux-x64-gnu": "14.2.29", "@next/swc-linux-x64-musl": "14.2.29", "@next/swc-win32-arm64-msvc": "14.2.29", "@next/swc-win32-ia32-msvc": "14.2.29", "@next/swc-win32-x64-msvc": "14.2.29" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0", "@playwright/test": "^1.41.2", "react": "^18.2.0", "react-dom": "^18.2.0", "sass": "^1.3.0" }, "optionalPeers": ["@opentelemetry/api", "@playwright/test", "sass"], "bin": { "next": "dist/bin/next" } }, "sha512-s98mCOMOWLGGpGOfgKSnleXLuegvvH415qtRZXpSp00HeEgdmrxmwL9cgKU+h4XrhB16zEI5d/7BnkS3ATInsA=="],
+    "next-runtime-env/next": ["next@14.2.30", "", { "dependencies": { "@next/env": "14.2.30", "@swc/helpers": "0.5.5", "busboy": "1.6.0", "caniuse-lite": "^1.0.30001579", "graceful-fs": "^4.2.11", "postcss": "8.4.31", "styled-jsx": "5.1.1" }, "optionalDependencies": { "@next/swc-darwin-arm64": "14.2.30", "@next/swc-darwin-x64": "14.2.30", "@next/swc-linux-arm64-gnu": "14.2.30", "@next/swc-linux-arm64-musl": "14.2.30", "@next/swc-linux-x64-gnu": "14.2.30", "@next/swc-linux-x64-musl": "14.2.30", "@next/swc-win32-arm64-msvc": "14.2.30", "@next/swc-win32-ia32-msvc": "14.2.30", "@next/swc-win32-x64-msvc": "14.2.30" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0", "@playwright/test": "^1.41.2", "react": "^18.2.0", "react-dom": "^18.2.0", "sass": "^1.3.0" }, "optionalPeers": ["@opentelemetry/api", "@playwright/test", "sass"], "bin": { "next": "dist/bin/next" } }, "sha512-+COdu6HQrHHFQ1S/8BBsCag61jZacmvbuL2avHvQFbWa2Ox7bE+d8FyNgxRLjXQ5wtPyQwEmk85js/AuaG2Sbg=="],
 
-    "openai/@types/node": ["@types/node@18.19.110", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-WW2o4gTmREtSnqKty9nhqF/vA0GKd0V/rbC0OyjSk9Bz6bzlsXKT+i7WDdS/a0z74rfT2PO4dArVCSnapNLA5Q=="],
+    "openai/@types/node": ["@types/node@18.19.112", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog=="],
 
     "openai/node-fetch": ["node-fetch@2.7.0", "", { "dependencies": { "whatwg-url": "^5.0.0" }, "peerDependencies": { "encoding": "^0.1.0" }, "optionalPeers": ["encoding"] }, "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A=="],
 
@@ -3524,8 +3539,6 @@
 
     "protobufjs/long": ["long@5.3.2", "", {}, "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA=="],
 
-    "randombytes/safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
-
     "react-email/chalk": ["chalk@5.4.1", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="],
 
     "react-email/chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="],
@@ -3534,7 +3547,7 @@
 
     "readdirp/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="],
 
-    "resend/@react-email/render": ["@react-email/render@1.0.6", "", { "dependencies": { "html-to-text": "9.0.5", "prettier": "3.5.3", "react-promise-suspense": "0.3.4" }, "peerDependencies": { "react": "^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^18.0 || ^19.0 || ^19.0.0-rc" } }, "sha512-zNueW5Wn/4jNC1c5LFgXzbUdv5Lhms+FWjOvWAhal7gx5YVf0q6dPJ0dnR70+ifo59gcMLwCZEaTS9EEuUhKvQ=="],
+    "resend/@react-email/render": ["@react-email/render@1.1.2", "", { "dependencies": { "html-to-text": "^9.0.5", "prettier": "^3.5.3", "react-promise-suspense": "^0.3.4" }, "peerDependencies": { "react": "^18.0 || ^19.0 || ^19.0.0-rc", "react-dom": "^18.0 || ^19.0 || ^19.0.0-rc" } }, "sha512-RnRehYN3v9gVlNMehHPHhyp2RQo7+pSkHDtXPvg3s0GbzM9SQMW4Qrf8GRNvtpLC4gsI+Wt0VatNRUFqjvevbw=="],
 
     "restore-cursor/signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="],
 
@@ -3542,9 +3555,9 @@
 
     "sim/tailwind-merge": ["tailwind-merge@2.6.0", "", {}, "sha512-P+Vu1qXfzediirmHOC3xKGAYeZtPcV9g76X+xg2FD4tYgR71ewMA35Y3sCz3zhiN/dwefRpJX0yBcgwi1fXNQA=="],
 
-    "simstudio/@types/node": ["@types/node@20.17.57", "", { "dependencies": { "undici-types": "~6.19.2" } }, "sha512-f3T4y6VU4fVQDKVqJV4Uppy8c1p/sVvS3peyqxyWnzkqXFJLRU7Y1Bl7rMS1Qe9z0v4M6McY0Fp9yBsgHJUsWQ=="],
+    "simstudio/@types/node": ["@types/node@20.19.1", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-jJD50LtlD2dodAEO653i3YF04NWak6jN3ky+Ri3Em3mGR39/glWiboM/IePaRbgwSfqM1TpGXfAg8ohn/4dTgA=="],
 
-    "simstudio-ts-sdk/@types/node": ["@types/node@20.17.57", "", { "dependencies": { "undici-types": "~6.19.2" } }, "sha512-f3T4y6VU4fVQDKVqJV4Uppy8c1p/sVvS3peyqxyWnzkqXFJLRU7Y1Bl7rMS1Qe9z0v4M6McY0Fp9yBsgHJUsWQ=="],
+    "simstudio-ts-sdk/@types/node": ["@types/node@20.19.1", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-jJD50LtlD2dodAEO653i3YF04NWak6jN3ky+Ri3Em3mGR39/glWiboM/IePaRbgwSfqM1TpGXfAg8ohn/4dTgA=="],
 
     "slice-ansi/ansi-styles": ["ansi-styles@6.2.1", "", {}, "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug=="],
 
@@ -3556,6 +3569,8 @@
 
     "socket.io-adapter/ws": ["ws@8.17.1", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ=="],
 
+    "socket.io-client/debug": ["debug@4.3.7", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ=="],
+
     "socket.io-parser/debug": ["debug@4.3.7", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ=="],
 
     "source-map-support/source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="],
@@ -3734,6 +3749,8 @@
 
     "@sentry/cli/node-fetch/whatwg-url": ["whatwg-url@5.0.0", "", { "dependencies": { "tr46": "~0.0.3", "webidl-conversions": "^3.0.0" } }, "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw=="],
 
+    "@sentry/nextjs/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
     "@sentry/node/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
 
     "@sentry/node/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.57.2", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-uIX52NnTM0iBh84MShlpouI7UKqkZ7MrUszTmaypHBu4r7NofznSnQRfJ+uUeDtQDj6w8eFGg5KBLDAwAPz1+A=="],
@@ -3742,12 +3759,12 @@
 
     "@sentry/node/@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
 
+    "@testing-library/jest-dom/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
     "@types/jest/pretty-format/react-is": ["react-is@17.0.2", "", {}, "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w=="],
 
     "accepts/mime-types/mime-db": ["mime-db@1.52.0", "", {}, "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg=="],
 
-    "bl/readable-stream/string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
-
     "cli-truncate/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="],
 
     "cli-truncate/string-width/strip-ansi": ["strip-ansi@7.1.0", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ=="],
@@ -3796,23 +3813,23 @@
 
     "log-update/wrap-ansi/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="],
 
-    "next-runtime-env/next/@next/env": ["@next/env@14.2.29", "", {}, "sha512-UzgLR2eBfhKIQt0aJ7PWH7XRPYw7SXz0Fpzdl5THjUnvxy4kfBk9OU4RNPNiETewEEtaBcExNFNn1QWH8wQTjg=="],
+    "next-runtime-env/next/@next/env": ["@next/env@14.2.30", "", {}, "sha512-KBiBKrDY6kxTQWGzKjQB7QirL3PiiOkV7KW98leHFjtVRKtft76Ra5qSA/SL75xT44dp6hOcqiiJ6iievLOYug=="],
 
-    "next-runtime-env/next/@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@14.2.29", "", { "os": "darwin", "cpu": "arm64" }, "sha512-wWtrAaxCVMejxPHFb1SK/PVV1WDIrXGs9ki0C/kUM8ubKHQm+3hU9MouUywCw8Wbhj3pewfHT2wjunLEr/TaLA=="],
+    "next-runtime-env/next/@next/swc-darwin-arm64": ["@next/swc-darwin-arm64@14.2.30", "", { "os": "darwin", "cpu": "arm64" }, "sha512-EAqfOTb3bTGh9+ewpO/jC59uACadRHM6TSA9DdxJB/6gxOpyV+zrbqeXiFTDy9uV6bmipFDkfpAskeaDcO+7/g=="],
 
-    "next-runtime-env/next/@next/swc-darwin-x64": ["@next/swc-darwin-x64@14.2.29", "", { "os": "darwin", "cpu": "x64" }, "sha512-7Z/jk+6EVBj4pNLw/JQrvZVrAh9Bv8q81zCFSfvTMZ51WySyEHWVpwCEaJY910LyBftv2F37kuDPQm0w9CEXyg=="],
+    "next-runtime-env/next/@next/swc-darwin-x64": ["@next/swc-darwin-x64@14.2.30", "", { "os": "darwin", "cpu": "x64" }, "sha512-TyO7Wz1IKE2kGv8dwQ0bmPL3s44EKVencOqwIY69myoS3rdpO1NPg5xPM5ymKu7nfX4oYJrpMxv8G9iqLsnL4A=="],
 
-    "next-runtime-env/next/@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@14.2.29", "", { "os": "linux", "cpu": "arm64" }, "sha512-o6hrz5xRBwi+G7JFTHc+RUsXo2lVXEfwh4/qsuWBMQq6aut+0w98WEnoNwAwt7hkEqegzvazf81dNiwo7KjITw=="],
+    "next-runtime-env/next/@next/swc-linux-arm64-gnu": ["@next/swc-linux-arm64-gnu@14.2.30", "", { "os": "linux", "cpu": "arm64" }, "sha512-I5lg1fgPJ7I5dk6mr3qCH1hJYKJu1FsfKSiTKoYwcuUf53HWTrEkwmMI0t5ojFKeA6Vu+SfT2zVy5NS0QLXV4Q=="],
 
-    "next-runtime-env/next/@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@14.2.29", "", { "os": "linux", "cpu": "arm64" }, "sha512-9i+JEHBOVgqxQ92HHRFlSW1EQXqa/89IVjtHgOqsShCcB/ZBjTtkWGi+SGCJaYyWkr/lzu51NTMCfKuBf7ULNw=="],
+    "next-runtime-env/next/@next/swc-linux-arm64-musl": ["@next/swc-linux-arm64-musl@14.2.30", "", { "os": "linux", "cpu": "arm64" }, "sha512-8GkNA+sLclQyxgzCDs2/2GSwBc92QLMrmYAmoP2xehe5MUKBLB2cgo34Yu242L1siSkwQkiV4YLdCnjwc/Micw=="],
 
-    "next-runtime-env/next/@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@14.2.29", "", { "os": "linux", "cpu": "x64" }, "sha512-B7JtMbkUwHijrGBOhgSQu2ncbCYq9E7PZ7MX58kxheiEOwdkM+jGx0cBb+rN5AeqF96JypEppK6i/bEL9T13lA=="],
+    "next-runtime-env/next/@next/swc-linux-x64-gnu": ["@next/swc-linux-x64-gnu@14.2.30", "", { "os": "linux", "cpu": "x64" }, "sha512-8Ly7okjssLuBoe8qaRCcjGtcMsv79hwzn/63wNeIkzJVFVX06h5S737XNr7DZwlsbTBDOyI6qbL2BJB5n6TV/w=="],
 
-    "next-runtime-env/next/@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@14.2.29", "", { "os": "linux", "cpu": "x64" }, "sha512-yCcZo1OrO3aQ38B5zctqKU1Z3klOohIxug6qdiKO3Q3qNye/1n6XIs01YJ+Uf+TdpZQ0fNrOQI2HrTLF3Zprnw=="],
+    "next-runtime-env/next/@next/swc-linux-x64-musl": ["@next/swc-linux-x64-musl@14.2.30", "", { "os": "linux", "cpu": "x64" }, "sha512-dBmV1lLNeX4mR7uI7KNVHsGQU+OgTG5RGFPi3tBJpsKPvOPtg9poyav/BYWrB3GPQL4dW5YGGgalwZ79WukbKQ=="],
 
-    "next-runtime-env/next/@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@14.2.29", "", { "os": "win32", "cpu": "arm64" }, "sha512-WnrfeOEtTVidI9Z6jDLy+gxrpDcEJtZva54LYC0bSKQqmyuHzl0ego+v0F/v2aXq0am67BRqo/ybmmt45Tzo4A=="],
+    "next-runtime-env/next/@next/swc-win32-arm64-msvc": ["@next/swc-win32-arm64-msvc@14.2.30", "", { "os": "win32", "cpu": "arm64" }, "sha512-6MMHi2Qc1Gkq+4YLXAgbYslE1f9zMGBikKMdmQRHXjkGPot1JY3n5/Qrbg40Uvbi8//wYnydPnyvNhI1DMUW1g=="],
 
-    "next-runtime-env/next/@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@14.2.29", "", { "os": "win32", "cpu": "x64" }, "sha512-iPPwUEKnVs7pwR0EBLJlwxLD7TTHWS/AoVZx1l9ZQzfQciqaFEr5AlYzA2uB6Fyby1IF18t4PL0nTpB+k4Tzlw=="],
+    "next-runtime-env/next/@next/swc-win32-x64-msvc": ["@next/swc-win32-x64-msvc@14.2.30", "", { "os": "win32", "cpu": "x64" }, "sha512-4KCo8hMZXMjpTzs3HOqOGYYwAXymXIy7PEPAXNEcEOyKqkjiDlECumrWziy+JEF0Oi4ILHGxzgQ3YiMGG2t/Lg=="],
 
     "next-runtime-env/next/@swc/helpers": ["@swc/helpers@0.5.5", "", { "dependencies": { "@swc/counter": "^0.1.3", "tslib": "^2.4.0" } }, "sha512-KGYxvIOXcceOAbEk4bi/dVLEK9z8sZ0uBB3Il5b1rhfClSpcX0yfRO0KmTkqR2cnQDymwLB+25ZyMzICg/cm/A=="],
 
@@ -3834,10 +3851,6 @@
 
     "react-email/chokidar/readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="],
 
-    "simstudio-ts-sdk/@types/node/undici-types": ["undici-types@6.19.8", "", {}, "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw=="],
-
-    "simstudio/@types/node/undici-types": ["undici-types@6.19.8", "", {}, "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw=="],
-
     "sucrase/glob/jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="],
 
     "sucrase/glob/path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="],
@@ -3874,8 +3887,6 @@
 
     "@sentry/cli/node-fetch/whatwg-url/webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],
 
-    "bl/readable-stream/string_decoder/safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
-
     "cli-truncate/string-width/strip-ansi/ansi-regex": ["ansi-regex@6.1.0", "", {}, "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA=="],
 
     "gaxios/node-fetch/whatwg-url/tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
diff --git a/package.json b/package.json
index ec682b3cbfa..e97588f3913 100644
--- a/package.json
+++ b/package.json
@@ -30,7 +30,8 @@
     "@linear/sdk": "40.0.0",
     "@t3-oss/env-nextjs": "0.13.4",
     "@vercel/analytics": "1.5.0",
-    "remark-gfm": "4.0.1"
+    "remark-gfm": "4.0.1",
+    "socket.io-client": "4.8.1"
   },
   "devDependencies": {
     "@biomejs/biome": "2.0.0-beta.5",
diff --git a/railway.json b/railway.json
new file mode 100644
index 00000000000..62d6da767e5
--- /dev/null
+++ b/railway.json
@@ -0,0 +1,21 @@
+{
+  "$schema": "https://railway.app/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS",
+    "buildCommand": "cd apps/sim && bun install --frozen-lockfile && bun run build"
+  },
+  "deploy": {
+    "startCommand": "cd apps/sim && NODE_ENV=production bun run socket-server/index.ts",
+    "healthcheckPath": "/health",
+    "healthcheckTimeout": 300,
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  },
+  "environments": {
+    "production": {
+      "variables": {
+        "NODE_ENV": "production"
+      }
+    }
+  }
+}