edda-framework 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

edda/viewer_ui/theme.py

@@ -0,0 +1,200 @@
+"""
+Theme configuration for Edda Workflow Viewer.
+
+Provides centralized color palette definitions and helper functions
+for light and dark mode support.
+"""
+
+from typing import Any, cast
+
+# Tailwind CSS compatible color palette
+COLORS: dict[str, dict[str, Any]] = {
+    "light": {
+        # Background colors
+        "bg_page": "#FFFFFF",
+        "bg_surface": "#F8FAFC",  # Slate 50
+        "bg_elevated": "#FFFFFF",
+        "border": "#E2E8F0",  # Slate 200
+        # Text colors
+        "text_primary": "#0F172A",  # Slate 900
+        "text_secondary": "#64748B",  # Slate 500
+        "text_muted": "#94A3B8",  # Slate 400
+        # Status colors (bg, stroke, text)
+        "completed": {"bg": "#ECFDF5", "stroke": "#10B981", "text": "#065F46"},
+        "running": {"bg": "#FEF3C7", "stroke": "#F59E0B", "text": "#92400E"},
+        "failed": {"bg": "#FEE2E2", "stroke": "#EF4444", "text": "#991B1B"},
+        "waiting_event": {"bg": "#DBEAFE", "stroke": "#3B82F6", "text": "#1E40AF"},
+        "waiting_timer": {"bg": "#E0F2FE", "stroke": "#0EA5E9", "text": "#075985"},
+        "cancelled": {"bg": "#FFEDD5", "stroke": "#F97316", "text": "#9A3412"},
+        "compensating": {"bg": "#F3E8FF", "stroke": "#A855F7", "text": "#6B21A8"},
+        "not_executed": {"bg": "#F1F5F9", "stroke": "#CBD5E1", "text": "#64748B"},
+        "event_received": {"bg": "#CFFAFE", "stroke": "#06B6D4", "text": "#0E7490"},
+        "compensation_failed": {"bg": "#FEE2E2", "stroke": "#B91C1C", "text": "#7F1D1D"},
+        # Mermaid diagram specific
+        "condition": {"bg": "#FEF3C7", "stroke": "#F59E0B"},
+        "loop": {"bg": "#FDF4FF", "stroke": "#D946EF"},
+        "match": {"bg": "#ECFDF5", "stroke": "#10B981"},
+        "merge": {"bg": "#FFFFFF", "stroke": "#E2E8F0"},
+        "edge_executed": "#10B981",
+        "edge_not_executed": "#CBD5E1",
+        "edge_compensation": "#A855F7",
+    },
+    "dark": {
+        # Background colors
+        "bg_page": "#0F172A",  # Slate 900
+        "bg_surface": "#1E293B",  # Slate 800
+        "bg_elevated": "#334155",  # Slate 700
+        "border": "#475569",  # Slate 600
+        # Text colors
+        "text_primary": "#F1F5F9",  # Slate 100
+        "text_secondary": "#94A3B8",  # Slate 400
+        "text_muted": "#64748B",  # Slate 500
+        # Status colors (bg, stroke, text)
+        "completed": {"bg": "#064E3B", "stroke": "#34D399", "text": "#A7F3D0"},
+        "running": {"bg": "#78350F", "stroke": "#FBBF24", "text": "#FDE68A"},
+        "failed": {"bg": "#7F1D1D", "stroke": "#F87171", "text": "#FECACA"},
+        "waiting_event": {"bg": "#1E3A8A", "stroke": "#60A5FA", "text": "#BFDBFE"},
+        "waiting_timer": {"bg": "#0C4A6E", "stroke": "#38BDF8", "text": "#BAE6FD"},
+        "cancelled": {"bg": "#7C2D12", "stroke": "#FB923C", "text": "#FED7AA"},
+        "compensating": {"bg": "#581C87", "stroke": "#C084FC", "text": "#E9D5FF"},
+        "not_executed": {"bg": "#334155", "stroke": "#64748B", "text": "#94A3B8"},
+        "event_received": {"bg": "#164E63", "stroke": "#22D3EE", "text": "#A5F3FC"},
+        "compensation_failed": {"bg": "#7F1D1D", "stroke": "#FCA5A5", "text": "#FECACA"},
+        # Mermaid diagram specific
+        "condition": {"bg": "#78350F", "stroke": "#FBBF24"},
+        "loop": {"bg": "#4C1D95", "stroke": "#E879F9"},
+        "match": {"bg": "#064E3B", "stroke": "#34D399"},
+        "merge": {"bg": "#1E293B", "stroke": "#475569"},
+        "edge_executed": "#34D399",
+        "edge_not_executed": "#64748B",
+        "edge_compensation": "#C084FC",
+    },
+}
+
+
+def get_status_color(status: str, is_dark: bool) -> dict[str, str]:
+    """
+    Get color configuration for a workflow status.
+
+    Args:
+        status: Status name (e.g., "completed", "running", "failed")
+        is_dark: Whether dark mode is enabled
+
+    Returns:
+        Dictionary with 'bg', 'stroke', and 'text' colors
+    """
+    theme = "dark" if is_dark else "light"
+    status_key = status.lower().replace(" ", "_").replace("-", "_")
+
+    # Handle special status mappings
+    status_mapping = {
+        "waiting": "waiting_event",
+        "waiting_for_event": "waiting_event",
+        "waiting_for_timer": "waiting_timer",
+        "compensated": "compensating",
+    }
+    status_key = status_mapping.get(status_key, status_key)
+
+    return cast(dict[str, str], COLORS[theme].get(status_key, COLORS[theme]["not_executed"]))
+
+
+def get_mermaid_style(status: str, is_dark: bool) -> str:
+    """
+    Get Mermaid style string for a status.
+
+    Args:
+        status: Status name
+        is_dark: Whether dark mode is enabled
+
+    Returns:
+        Mermaid style string (e.g., "fill:#ECFDF5,stroke:#10B981,stroke-width:2px")
+    """
+    colors = get_status_color(status, is_dark)
+    return f"fill:{colors['bg']},stroke:{colors['stroke']},stroke-width:2px"
+
+
+def get_mermaid_node_style(node_type: str, is_dark: bool) -> str:
+    """
+    Get Mermaid style for structural nodes (condition, loop, merge).
+
+    Args:
+        node_type: Node type (e.g., "condition", "loop", "merge")
+        is_dark: Whether dark mode is enabled
+
+    Returns:
+        Mermaid style string
+    """
+    theme = "dark" if is_dark else "light"
+    colors = COLORS[theme].get(node_type, COLORS[theme]["merge"])
+    stroke_width = "1px" if node_type == "merge" else "2px"
+    return f"fill:{colors['bg']},stroke:{colors['stroke']},stroke-width:{stroke_width}"
+
+
+def get_edge_color(edge_type: str, is_dark: bool) -> str:
+    """
+    Get edge (arrow) color for Mermaid diagrams.
+
+    Args:
+        edge_type: Edge type ("executed", "not_executed", "compensation")
+        is_dark: Whether dark mode is enabled
+
+    Returns:
+        Color hex code
+    """
+    theme = "dark" if is_dark else "light"
+    key = f"edge_{edge_type}"
+    return cast(str, COLORS[theme].get(key, COLORS[theme]["edge_not_executed"]))
+
+
+# Tailwind CSS class mappings for UI components
+# Note: Background colors are controlled via CSS in app.py for proper dark mode support
+# NiceGUI adds 'dark' class to body, but Tailwind's dark: prefix expects it on html
+TAILWIND_CLASSES = {
+    "card": "border",  # Background handled by CSS
+    "card_hover": "",  # Hover handled by CSS
+    "surface": "",  # Background handled by CSS
+    "text_primary": "text-slate-900 dark:text-slate-100",
+    "text_secondary": "text-slate-500 dark:text-slate-400",
+    "text_muted": "text-slate-400 dark:text-slate-500",
+    "border": "border-slate-200 dark:border-slate-700",
+    "input": "border-slate-300 dark:border-slate-600",  # Background handled by CSS
+    "code_block": "border",  # Background handled by CSS
+}
+
+# Status badge Tailwind classes
+STATUS_BADGE_CLASSES = {
+    "completed": ("bg-emerald-50 text-emerald-700 dark:bg-emerald-900/50 dark:text-emerald-300"),
+    "running": "bg-amber-50 text-amber-700 dark:bg-amber-900/50 dark:text-amber-300",
+    "failed": "bg-red-50 text-red-700 dark:bg-red-900/50 dark:text-red-300",
+    "waiting_event": "bg-blue-50 text-blue-700 dark:bg-blue-900/50 dark:text-blue-300",
+    "waiting_timer": "bg-sky-50 text-sky-700 dark:bg-sky-900/50 dark:text-sky-300",
+    "cancelled": ("bg-orange-50 text-orange-700 dark:bg-orange-900/50 dark:text-orange-300"),
+    "compensating": ("bg-purple-50 text-purple-700 dark:bg-purple-900/50 dark:text-purple-300"),
+    "not_executed": ("bg-slate-100 text-slate-600 dark:bg-slate-700 dark:text-slate-400"),
+}
+
+
+def get_status_badge_classes(status: str) -> str:
+    """
+    Get Tailwind CSS classes for a status badge.
+
+    Args:
+        status: Status name
+
+    Returns:
+        Tailwind CSS class string
+    """
+    status_key = status.lower().replace(" ", "_").replace("-", "_")
+
+    # Handle special status mappings
+    status_mapping = {
+        "waiting": "waiting_event",
+        "waiting_for_event": "waiting_event",
+        "waiting_for_timer": "waiting_timer",
+        "compensated": "compensating",
+    }
+    status_key = status_mapping.get(status_key, status_key)
+
+    base_classes = "px-3 py-1 rounded-full text-sm font-medium"
+    status_classes = STATUS_BADGE_CLASSES.get(status_key, STATUS_BADGE_CLASSES["not_executed"])
+    return f"{base_classes} {status_classes}"

edda/workflow.py

@@ -14,6 +14,49 @@ from edda.pydantic_utils import to_json_dict
 
 F = TypeVar("F", bound=Callable[..., Any])
 
+
+class RecurException(Exception):
+    """
+    Exception raised to signal that a workflow should recur (restart with fresh history).
+
+    This is similar to Erlang's tail recursion pattern - it prevents unbounded history
+    growth in long-running loops by completing the current workflow instance and
+    starting a new one with the provided arguments.
+
+    The workflow's history is archived (not deleted) and a new instance is created
+    with a reference to the previous instance (continued_from).
+
+    Note:
+        This exception should not be caught by user code. It is handled internally
+        by the ReplayEngine.
+
+    Example:
+        >>> @workflow
+        ... async def notification_service(ctx: WorkflowContext, processed_count: int = 0):
+        ...     await join_group(ctx, group="order_watchers")
+        ...
+        ...     count = 0
+        ...     while True:
+        ...         msg = await wait_message(ctx, channel="order.completed")
+        ...         await send_notification(ctx, msg.data, activity_id=f"notify:{msg.id}")
+        ...
+        ...         count += 1
+        ...         if count >= 1000:
+        ...             # Reset history by recurring with new state
+        ...             await ctx.recur(processed_count=processed_count + count)
+    """
+
+    def __init__(self, kwargs: dict[str, Any]):
+        """
+        Initialize RecurException.
+
+        Args:
+            kwargs: Keyword arguments to pass to the new workflow instance
+        """
+        self.kwargs = kwargs
+        super().__init__("Workflow recur requested")
+
+
 # Global registry of workflow instances (will be set by EddaApp)
 _replay_engine: Any = None
 

{edda_framework-0.6.0.dist-info → edda_framework-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edda-framework
-Version: 0.6.0
+Version: 0.8.0
 Summary: Lightweight Durable Execution Framework
 Project-URL: Homepage, https://github.com/i2y/edda
 Project-URL: Documentation, https://github.com/i2y/edda#readme
@@ -30,11 +30,13 @@ Requires-Dist: sqlalchemy[asyncio]>=2.0.0
 Requires-Dist: uvloop>=0.22.1
 Provides-Extra: dev
 Requires-Dist: black>=25.9.0; extra == 'dev'
+Requires-Dist: mcp>=1.22.0; extra == 'dev'
 Requires-Dist: mypy>=1.18.2; extra == 'dev'
 Requires-Dist: pytest-asyncio>=1.2.0; extra == 'dev'
 Requires-Dist: pytest-cov>=7.0.0; extra == 'dev'
 Requires-Dist: pytest>=8.4.2; extra == 'dev'
 Requires-Dist: ruff>=0.14.2; extra == 'dev'
+Requires-Dist: starlette>=0.40.0; extra == 'dev'
 Requires-Dist: testcontainers[mysql]>=4.0.0; extra == 'dev'
 Requires-Dist: testcontainers[postgres]>=4.0.0; extra == 'dev'
 Requires-Dist: tsuno>=0.1.3; extra == 'dev'
@@ -83,6 +85,7 @@ For detailed documentation, visit [https://i2y.github.io/edda/](https://i2y.gith
 - 📦 **Transactional Outbox**: Reliable event publishing with guaranteed delivery
 - ☁️ **CloudEvents Support**: Native support for CloudEvents protocol
 - ⏱️ **Event & Timer Waiting**: Free up worker resources while waiting for events or timers, resume on any available worker
+- 📬 **Channel-based Messaging**: Actor-model style communication with competing (job queue) and broadcast (fan-out) modes
 - 🤖 **MCP Integration**: Expose durable workflows as AI tools via Model Context Protocol
 - 🌍 **ASGI/WSGI Support**: Deploy with your preferred server (uvicorn, gunicorn, uWSGI)
 
@@ -105,14 +108,14 @@ Edda's waiting functions make it ideal for time-based and event-driven business
 - **📦 Scheduled Notifications**: Shipping updates, subscription renewals, appointment reminders
 
 **Waiting functions**:
-- `wait_timer(duration_seconds)`: Wait for a relative duration
-- `wait_until(until_time)`: Wait until an absolute datetime (e.g., campaign end date)
+- `sleep(seconds)`: Wait for a relative duration
+- `sleep_until(target_time)`: Wait until an absolute datetime (e.g., campaign end date)
 - `wait_event(event_type)`: Wait for external events (near real-time response)
 
 ```python
 @workflow
 async def onboarding_reminder(ctx: WorkflowContext, user_id: str):
-    await wait_timer(ctx, duration_seconds=3*24*60*60)  # Wait 3 days
+    await sleep(ctx, seconds=3*24*60*60)  # Wait 3 days
     if not await check_completed(ctx, user_id):
         await send_reminder(ctx, user_id)
 ```
@@ -164,7 +167,7 @@ graph TB
 
 - Multiple workers can run simultaneously across different pods/servers
 - Each workflow instance runs on only one worker at a time (automatic coordination)
-- `wait_event()` and `wait_timer()` free up worker resources while waiting, resume on any worker when event arrives or timer expires
+- `wait_event()` and `sleep()` free up worker resources while waiting, resume on any worker when event arrives or timer expires
 - Automatic crash recovery with stale lock cleanup and workflow auto-resume
 
 ## Quick Start
@@ -484,7 +487,10 @@ Multiple workers can safely process workflows using database-based exclusive con
 
 app = EddaApp(
     db_url="postgresql://localhost/workflows",  # Shared database for coordination
-    service_name="order-service"
+    service_name="order-service",
+    # Connection pool settings (optional)
+    pool_size=5,        # Concurrent connections
+    max_overflow=10,    # Additional burst capacity
 )
 ```
 
@@ -612,10 +618,32 @@ async def payment_workflow(ctx: WorkflowContext, order_id: str):
     return payment_event.data
 ```
 
-**wait_timer() for time-based waiting**:
+**ReceivedEvent attributes**: The `wait_event()` function returns a `ReceivedEvent` object:
+
+```python
+event = await wait_event(ctx, "payment.completed")
+amount = event.data["amount"]           # Event payload (dict or bytes)
+source = event.metadata.source          # CloudEvents source
+event_type = event.metadata.type        # CloudEvents type
+extensions = event.extensions           # CloudEvents extensions
+```
+
+**Timeout handling with EventTimeoutError**:
 
 ```python
-from edda import wait_timer
+from edda import wait_event, EventTimeoutError
+
+try:
+    event = await wait_event(ctx, "payment.completed", timeout_seconds=60)
+except EventTimeoutError:
+    # Handle timeout (e.g., cancel order, send reminder)
+    await cancel_order(ctx, order_id)
+```
+
+**sleep() for time-based waiting**:
+
+```python
+from edda import sleep
 
 @workflow
 async def order_with_timeout(ctx: WorkflowContext, order_id: str):
@@ -623,7 +651,7 @@ async def order_with_timeout(ctx: WorkflowContext, order_id: str):
     await create_order(ctx, order_id)
 
     # Wait 60 seconds for payment
-    await wait_timer(ctx, duration_seconds=60)
+    await sleep(ctx, seconds=60)
 
     # Check payment status
     return await check_payment(ctx, order_id)
@@ -637,6 +665,136 @@ async def order_with_timeout(ctx: WorkflowContext, order_id: str):
 
 **For technical details**, see [Multi-Worker Continuations](local-docs/distributed-coroutines.md).
 
+### Message Passing (Workflow-to-Workflow)
+
+Edda provides actor-model style message passing for direct workflow-to-workflow communication:
+
+```python
+from edda import workflow, wait_message, send_message_to, WorkflowContext
+
+# Receiver workflow - waits for approval message
+@workflow
+async def approval_workflow(ctx: WorkflowContext, request_id: str):
+    # Wait for message on "approval" channel
+    msg = await wait_message(ctx, channel="approval")
+
+    if msg.data["approved"]:
+        return {"status": "approved", "approver": msg.data["approver"]}
+    return {"status": "rejected"}
+
+# Sender workflow - sends approval decision
+@workflow
+async def manager_workflow(ctx: WorkflowContext, request_id: str):
+    # Review and make decision
+    decision = await review_request(ctx, request_id)
+
+    # Send message to waiting workflow
+    await send_message_to(
+        ctx,
+        target_instance_id=request_id,
+        channel="approval",
+        data={"approved": decision, "approver": "manager-123"},
+    )
+```
+
+**Group Communication (Erlang pg style)** - for fan-out messaging without knowing receiver instance IDs:
+
+```python
+from edda import workflow, join_group, wait_message, publish_to_group
+
+# Receiver workflow - joins a group and listens
+@workflow
+async def notification_service(ctx: WorkflowContext, service_id: str):
+    # Join group at startup (loose coupling - sender doesn't need to know us)
+    await join_group(ctx, group="order_watchers")
+
+    while True:
+        msg = await wait_message(ctx, channel="order.created")
+        await send_notification(ctx, msg.data)
+
+# Sender workflow - publishes to all group members
+@workflow
+async def order_processor(ctx: WorkflowContext, order_id: str):
+    result = await process_order(ctx, order_id)
+
+    # Broadcast to all watchers (doesn't need to know instance IDs)
+    count = await publish_to_group(
+        ctx,
+        group="order_watchers",
+        channel="order.created",
+        data={"order_id": order_id, "status": "completed"},
+    )
+    print(f"Notified {count} watchers")
+```
+
+**Channel API with Delivery Modes** - subscribe to channels with explicit delivery semantics:
+
+```python
+from edda import workflow, subscribe, receive, publish, WorkflowContext
+
+# Job Worker - processes jobs exclusively (competing mode)
+@workflow
+async def job_worker(ctx: WorkflowContext, worker_id: str):
+    # Subscribe with competing mode - each job goes to ONE worker only
+    await subscribe(ctx, channel="jobs", mode="competing")
+
+    while True:
+        job = await receive(ctx, channel="jobs")  # Get next job
+        await process_job(ctx, job.data)
+        await ctx.recur(worker_id)  # Continue processing
+
+# Notification Handler - receives ALL messages (broadcast mode)
+@workflow
+async def notification_handler(ctx: WorkflowContext, handler_id: str):
+    # Subscribe with broadcast mode - ALL handlers receive each message
+    await subscribe(ctx, channel="notifications", mode="broadcast")
+
+    while True:
+        msg = await receive(ctx, channel="notifications")
+        await send_notification(ctx, msg.data)
+        await ctx.recur(handler_id)
+
+# Publisher - send messages to channel
+await publish(ctx, channel="jobs", data={"task": "send_report"})
+```
+
+**Delivery modes**:
+- **`competing`**: Each message goes to exactly ONE subscriber (job queue/task distribution)
+- **`broadcast`**: Each message goes to ALL subscribers (notifications/fan-out)
+
+**Key features**:
+- **Channel-based messaging**: Messages are delivered to workflows waiting on specific channels
+- **Competing vs Broadcast**: Choose semantics per subscription
+- **Group communication**: Erlang pg-style groups for loose coupling and fan-out
+- **Database-backed**: All messages are persisted for durability
+- **Lock-first delivery**: Safe for multi-worker environments
+
+### Workflow Recurrence
+
+Long-running workflows can use `ctx.recur()` to restart with fresh history while maintaining the same instance ID. This is essential for workflows that run indefinitely (job workers, notification handlers, etc.):
+
+```python
+from edda import workflow, subscribe, receive, WorkflowContext
+
+@workflow
+async def job_worker(ctx: WorkflowContext, worker_id: str):
+    await subscribe(ctx, channel="jobs", mode="competing")
+
+    # Process one job
+    job = await receive(ctx, channel="jobs")
+    await process_job(ctx, job.data)
+
+    # Archive history and restart with same instance_id
+    # Prevents unbounded history growth
+    await ctx.recur(worker_id)
+```
+
+**Key benefits**:
+- **Prevents history growth**: Archives old history, starts fresh
+- **Maintains instance ID**: Same workflow continues logically
+- **Preserves subscriptions**: Channel subscriptions survive recurrence
+- **Enables infinite loops**: Essential for long-running workers
+
 ### ASGI Integration
 
 Edda runs as an ASGI application:

{edda_framework-0.6.0.dist-info → edda_framework-0.8.0.dist-info}/RECORD

@@ -1,23 +1,23 @@
-edda/__init__.py,sha256=gmJd0ooVbGNMOLlSj-r6rEt3IkY-FZYCFjhWjIltqlk,1657
+edda/__init__.py,sha256=hGC6WR2R36M8LWC97F-0Rw4Ln0QUUT_1xC-7acOy_Fk,2237
 edda/activity.py,sha256=nRm9eBrr0lFe4ZRQ2whyZ6mo5xd171ITIVhqytUhOpw,21025
-edda/app.py,sha256=8FKx9Kspbm5Fz-QDz4DgncNkkgdZkij209LHllWkRw4,38288
-edda/compensation.py,sha256=CmnyJy4jAklVrtLJodNOcj6vxET6pdarxM1Yx2RHlL4,11898
-edda/context.py,sha256=YZKBNtblRcaFqte1Y9t2cIP3JHzK-5Tu40x5i5FHtnU,17789
-edda/events.py,sha256=KN06o-Umkwkg9-TwbN4jr1uBZrBrvVSc6m8mOlQGXkA,18043
+edda/app.py,sha256=kZ-VEvjIe3GjUA8RhT6OimuezNyPf2IhrvQ2kL44zJs,45201
+edda/channels.py,sha256=ozaXCcWMLwgu_i6p8I79C9FnfsoQ0uv2BpaPPonTJdc,33863
+edda/compensation.py,sha256=iKLlnTxiF1YSatmYQW84EkPB1yMKUEZBtgjuGnghLtY,11824
+edda/context.py,sha256=kxWok86IwLF7hvxlE803t7ayPySTzCKoW113TmwON1k,19752
 edda/exceptions.py,sha256=-ntBLGpVQgPFG5N1o8m_7weejAYkNrUdxTkOP38vsHk,1766
 edda/hooks.py,sha256=HUZ6FTM__DZjwuomDfTDEroQ3mugEPuJHcGm7CTQNvg,8193
-edda/locking.py,sha256=l3YM7zdERizw27jQXfLN7EmcMcrJSVzd7LD8hhsXvIM,11003
+edda/locking.py,sha256=NAFJmw-JaSVsXn4Y4czJyv_s9bWG8cdrzDBWIEag5X8,13661
 edda/pydantic_utils.py,sha256=dGVPNrrttDeq1k233PopCtjORYjZitsgASPfPnO6R10,9056
-edda/replay.py,sha256=5RIRd0q2ZrH9iiiy35eOUii2cipYg9dlua56OAXvIk4,32499
+edda/replay.py,sha256=_poGUfvsDJP8GiflAw6aCZzxMKJpo99z__JVdGHb75I,42567
 edda/retry.py,sha256=t4_E1skrhotA1XWHTLbKi-DOgCMasOUnhI9OT-O_eCE,6843
-edda/workflow.py,sha256=daSppYAzgXkjY_9-HS93Zi7_tPR6srmchxY5YfwgU-4,7239
+edda/workflow.py,sha256=hfBZM0JrtK0IkvZSrva0VmYVyvKCdiJ5FWFmIVENfrM,8807
 edda/wsgi.py,sha256=1pGE5fhHpcsYnDR8S3NEFKWUs5P0JK4roTAzX9BsIj0,2391
 edda/integrations/__init__.py,sha256=F_CaTvlDEbldfOpPKq_U9ve1E573tS6XzqXnOtyHcXI,33
 edda/integrations/mcp/__init__.py,sha256=YK-8m0DIdP-RSqewlIX7xnWU7TD3NioCiW2_aZSgnn8,1232
 edda/integrations/mcp/decorators.py,sha256=31SmbDwmHEGvUNa3aaatW91hBkpnS5iN9uy47dID3J4,10037
 edda/integrations/mcp/server.py,sha256=Q5r4AbMn-9gBcy2CZocbgW7O0fn7Qb4e9CBJa1FEmzU,14507
 edda/integrations/opentelemetry/__init__.py,sha256=x1_PyyygGDW-rxQTwoIrGzyjKErXHOOKdquFAMlCOAo,906
-edda/integrations/opentelemetry/hooks.py,sha256=FBYnSZBh8_0vw9M1E2AbJrx1cTTsKeiHf5wspr0UnzU,21288
+edda/integrations/opentelemetry/hooks.py,sha256=rCb6K_gJJMxjQ-UoJnbIOWsafapipzu7w-YPROZKxDA,21330
 edda/outbox/__init__.py,sha256=azXG1rtheJEjOyoWmMsBeR2jp8Bz02R3wDEd5tQnaWA,424
 edda/outbox/relayer.py,sha256=2tnN1aOQ8pKWfwEGIlYwYLLwyOKXBjZ4XZsIr1HjgK4,9454
 edda/outbox/transactional.py,sha256=LFfUjunqRlGibaINi-efGXFFivWGO7v3mhqrqyGW6Nw,3808
@@ -25,18 +25,19 @@ edda/serialization/__init__.py,sha256=hnOVJN-mJNIsSa_XH9jwhIydOsWvIfCaFaSd37HUpl
 edda/serialization/base.py,sha256=xJy2CY9gdJDCF0tmCor8NomL2Lr_w7cveVvxccuc-tA,1998
 edda/serialization/json.py,sha256=Dq96V4n1yozexjCPd_CL6Iuvh1u3jJhef6sTcNxXZeA,2842
 edda/storage/__init__.py,sha256=Q-kNJsjF8hMc2Q5MYFlLBENKExlNlKkbmUkwBOosj9I,216
-edda/storage/models.py,sha256=usVPKLV4H1-LA6QC72_gkfYrG9T8AwkcmCXppBo-2gQ,7338
-edda/storage/protocol.py,sha256=ws9gDhiHpL1XglkdbN_-ayP_2GiIc-B9qt8bcrO2TG0,24957
-edda/storage/sqlalchemy_storage.py,sha256=z3OepqxVUHnknnPJj19Vii3SB4n_RI_Zu7Tz70gtwOI,71144
+edda/storage/models.py,sha256=E_KFygX6DP2qRwgLGLiKPhcXdKtvnfKeqA2kMXcAchE,13188
+edda/storage/protocol.py,sha256=0E5QSUDtSMlJX_lF6m3VAUx3WO6Qjm-Kq6_bXI7P52I,39841
+edda/storage/sqlalchemy_storage.py,sha256=eswQxCyY2DdUNYdrkxW_7Pev6CHCohNb72kGJjf29tA,140825
 edda/viewer_ui/__init__.py,sha256=N1-T33SXadOXcBsDSgJJ9Iqz4y4verJngWryQu70c5c,517
-edda/viewer_ui/app.py,sha256=VXVEiS07w76GGpTybWcgUeygfCUFpmAbGK_CxMk6EFs,75455
-edda/viewer_ui/components.py,sha256=Fx78Im3-TvAfwIckGKmvdT_qMKw5m_qrwNcQEI7ci6M,44664
-edda/viewer_ui/data_service.py,sha256=mXV6bL6REa_UKsk8xMGBIFbsbLpIxe91lX3wgn-FOjw,34843
+edda/viewer_ui/app.py,sha256=CqHKsUj5pcysHCk0aRfkEqV4DIV4l3GzOPKBJ5DTYOQ,95624
+edda/viewer_ui/components.py,sha256=A0IxLwgj_Lu51O57OfzOwME8jzoJtKegEVvSnWc7uPo,45174
+edda/viewer_ui/data_service.py,sha256=yzmPz67rBoECY7eNK5nl6YS3jIZAi-haaqrP0GIgJYE,36373
+edda/viewer_ui/theme.py,sha256=mrXoXLRzgSnvE2a58LuMcPJkhlvHEDMWVa8Smqtk4l0,8118
 edda/visualizer/__init__.py,sha256=DOpDstNhR0VcXAs_eMKxaL30p_0u4PKZ4o2ndnYhiRo,343
 edda/visualizer/ast_analyzer.py,sha256=plmx7C9X_X35xLY80jxOL3ljg3afXxBePRZubqUIkxY,13663
 edda/visualizer/mermaid_generator.py,sha256=XWa2egoOTNDfJEjPcwoxwQmblUqXf7YInWFjFRI1QGo,12457
-edda_framework-0.6.0.dist-info/METADATA,sha256=sxR8GtZNOzswVHIh8n_uAojtOrUEn_mXbT9Li5IvTnk,31702
-edda_framework-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-edda_framework-0.6.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
-edda_framework-0.6.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
-edda_framework-0.6.0.dist-info/RECORD,,
+edda_framework-0.8.0.dist-info/METADATA,sha256=o5ANdknKkLtOAGnKZ_IIQ0D3Q2iKyccdYVB-jjf8LLA,37506
+edda_framework-0.8.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+edda_framework-0.8.0.dist-info/entry_points.txt,sha256=dPH47s6UoJgUZxHoeSMqZsQkLaSE-SGLi-gh88k2WrU,48
+edda_framework-0.8.0.dist-info/licenses/LICENSE,sha256=udxb-V7_cYKTHqW7lNm48rxJ-Zpf0WAY_PyGDK9BPCo,1069
+edda_framework-0.8.0.dist-info/RECORD,,

{edda_framework-0.6.0.dist-info → edda_framework-0.8.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any