update project description

Author: nassor

README.md

@@ -1,6 +1,6 @@
 <div align="center">
   <img src="docs/logo.png" alt="Cano Logo" width="200">
-  <h1>Cano: Async Data & AI Workflows in Rust</h1>
+  <h1>Cano: Type-Safe Async Workflow Engine</h1>
 
 [![Crates.io](https://img.shields.io/crates/v/cano.svg)](https://crates.io/crates/cano)
 [![Documentation](https://docs.rs/cano/badge.svg)](https://docs.rs/cano)
@@ -9,13 +9,18 @@
 [![License](https://img.shields.io/crates/l/cano.svg)](https://github.com/nassor/cano/blob/main/LICENSE)
 [![CI](https://github.com/nassor/cano/workflows/CI/badge.svg)](https://github.com/nassor/cano/actions)
 
-<em>**Async workflow engine with built-in scheduling, retry logic, and state machine semantics.**</em>
+<em>**Orchestrate complex async processes with finite state machines, parallel execution, and built-in scheduling.**</em>
 </div>
 
 # Overview
-Cano is an async workflow engine for Rust that manages complex processing through composable workflows. It can be used for data processing, AI inference workflows, and background jobs. Cano provides a simple, fast and type-safe API for defining workflows with retry strategies, scheduling capabilities, and shared state management.
+Cano is a high-performance orchestration engine designed for building resilient, self-healing systems in Rust. Unlike simple task queues, Cano uses **Finite State Machines (FSM)** to define strict, type-safe transitions between processing steps.
 
-The engine is built on three core concepts: **Tasks** and **Nodes** to encapsulate business logic, **Workflows** to manage state transitions, and **Schedulers** to run workflows on a schedule.
+It excels at managing complex lifecycles where state transitions matter:
+*   **Data Pipelines**: ETL jobs with parallel processing (Split/Join) and aggregation.
+*   **AI Agents**: Multi-step inference chains with shared context and memory.
+*   **Background Systems**: Scheduled maintenance, periodic reporting, and distributed cron jobs.
+
+The engine is built on three core concepts: **Tasks/Nodes** for logic, **Workflows** for state transitions, and **Schedulers** for timing.
 
 *The Node API is inspired by the [PocketFlow](https://github.com/The-Pocket/PocketFlow) project, adapted for Rust's async ecosystem.*
 
@@ -30,7 +35,7 @@ The engine is built on three core concepts: **Tasks** and **Nodes** to encapsula
 - **Observability**: Integrated `tracing` support for deep insights into workflow execution.
 - **Zero-Cost Abstractions**: Minimal overhead designed for high-performance async Rust.
 
-## Complex Example: Parallel Processing
+## Simple Example: Parallel Processing
 
 Here is a real-world example showing how to split execution into parallel tasks and join them back together.
 

docs/index.html

@@ -33,7 +33,7 @@
 
     <main class="main-content">
         <h1>Cano</h1>
-        <p class="subtitle">Async workflow engine with built-in scheduling, retry logic, and state machine semantics.</p>
+        <p class="subtitle">Type-safe async workflow engine with built-in scheduling, retry logic, and state machine semantics.</p>
 
         <div class="badges" style="margin: 2rem 0; display: flex; gap: 0.5rem;">
             <img src="https://img.shields.io/crates/v/cano.svg" alt="Crates.io">
@@ -43,11 +43,18 @@ <h1>Cano</h1>
         </div>
 
         <p>
-            Cano is an async workflow engine for Rust that manages complex processing through composable workflows. 
-            It can be used for data processing, AI inference workflows, and background jobs. 
-            Cano provides a simple, fast and type-safe API for defining workflows with retry strategies, 
-            scheduling capabilities, and shared state management.
+            Cano is a high-performance orchestration engine designed for building resilient, self-healing systems in Rust. 
+            Unlike simple task queues, Cano uses <strong>Finite State Machines (FSM)</strong> to define strict, type-safe transitions between processing steps.
         </p>
+        
+        <p>
+            It excels at managing complex lifecycles where state transitions matter:
+        </p>
+        <ul>
+            <li><strong>Data Pipelines</strong>: ETL jobs with parallel processing (Split/Join) and aggregation.</li>
+            <li><strong>AI Agents</strong>: Multi-step inference chains with shared context and memory.</li>
+            <li><strong>Background Systems</strong>: Scheduled maintenance, periodic reporting, and distributed cron jobs.</li>
+        </ul>
 
         <h2>Features</h2>
         <div class="card-grid">

docs/scheduler.html

@@ -126,6 +126,8 @@ <h3>2. Cron Scheduling - Time-Based Expressions</h3>
                 section Workflow
                 Run 1 :09, 1h
                 Run 2 :18, 1h
+                %% Add empty space to ensure full visibility
+                Space :20, 0h
         </div>
 
         <pre><code class="language-rust">use cano::prelude::*;

src/lib.rs

@@ -1,7 +1,12 @@
-//! # Cano: Simple & Fast Async Workflows in Rust
+//! # Cano: Type-Safe Async Workflow Engine
 //!
-//! Cano is an async workflow engine that makes complex data processing simple. Whether you need
-//! to process one item or millions, Cano provides a clean API with minimal overhead for maximum performance.
+//! Cano is a high-performance orchestration engine designed for building resilient, self-healing systems in Rust.
+//! Unlike simple task queues, Cano uses **Finite State Machines (FSM)** to define strict, type-safe transitions between processing steps.
+//!
+//! It excels at managing complex lifecycles where state transitions matter:
+//! *   **Data Pipelines**: ETL jobs with parallel processing (Split/Join) and aggregation.
+//! *   **AI Agents**: Multi-step inference chains with shared context and memory.
+//! *   **Background Systems**: Scheduled maintenance, periodic reporting, and distributed cron jobs.
 //!
 //! ## 🚀 Quick Start
 //!
@@ -11,6 +16,12 @@
 //!
 //! ## 🎯 Core Concepts
 //!
+//! ### Finite State Machines (FSM)
+//!
+//! Workflows in Cano are state machines. You define your states as an `enum`, and register
+//! handlers ([`Task`] or [`Node`]) for each state. The engine ensures type safety and
+//! manages transitions between states.
+//!
 //! ### Tasks & Nodes - Your Processing Units
 //!
 //! **Two approaches for implementing processing logic:**
@@ -19,19 +30,17 @@
 //!
 //! **Every [`Node`] automatically implements [`Task`]**, providing seamless interoperability and upgrade paths.
 //!
+//! ### Parallel Execution (Split/Join)
+//!
+//! Run tasks concurrently and join results with strategies like `All`, `Any`, `Quorum`, or `PartialResults`.
+//! This allows for powerful patterns like scatter-gather, redundant execution, and latency optimization.
+//!
 //! ### Store - Share Data Between Processing Units
 //!
 //! Use [`MemoryStore`] to pass data around your workflow. Store different types of data
 //! using key-value pairs, and retrieve them later with type safety. All values are
 //! wrapped in `std::borrow::Cow` for memory efficiency.
 //!
-//! ### Custom Logic - Your Business Implementation
-//!
-//! **Choose the right approach for your needs:**
-//! - Implement the [`Task`] trait for simple, single-method processing
-//! - Implement the [`Node`] trait for structured processing with three phases:
-//!   Prep (load data, validate inputs), Exec (core processing), and Post (store results, determine next action)
-//!
 //! ## 🏗️ Processing Lifecycle
 //!
 //! **Task**: Single `run()` method with full control over execution flow
@@ -56,7 +65,7 @@
 //!   - Fluent configuration API via [`TaskConfig`]
 //!
 //! - **[`workflow`]**: Core workflow orchestration
-//!   - [`Workflow`] for state machine-based workflows
+//!   - [`Workflow`] for state machine-based workflows with Split/Join support
 //!
 //! - **[`scheduler`]** (optional `scheduler` feature): Advanced workflow scheduling
 //!   - [`Scheduler`] for managing multiple flows with cron support