docs: Update README and docs for v2.1.1 features

Document filter, log, channel routing, workflow lifecycle, engine
hot reload, and typed integration configs across README and mdbook.

Author: shankar-gpio

README.md

@@ -122,8 +122,13 @@ let engine = RulesEngine::new(vec![rule], None);
 - **Full Context Access:** Conditions can access any field — `data`, `metadata`, `temp_data`.
 - **Async-First Architecture:** Native async/await support with Tokio for high-throughput processing.
 - **Execution Tracing:** Step-by-step debugging with message snapshots after each action.
-- **Built-in Functions:** Parse (JSON/XML), Map, Validate, and Publish (JSON/XML) for complete data pipelines.
+- **Built-in Functions:** Parse, Map, Validate, Filter, Log, and Publish for complete data pipelines.
+- **Pipeline Control Flow:** Filter/gate function to halt workflows or skip tasks based on conditions.
+- **Channel Routing:** Route messages to specific workflow channels with O(1) lookup.
+- **Workflow Lifecycle:** Manage workflow status (active/paused/archived), versioning, and tagging.
+- **Hot Reload:** Swap workflows at runtime without re-registering custom functions.
 - **Extensible:** Add custom async actions by implementing the `AsyncFunctionHandler` trait.
+- **Typed Integration Configs:** Pre-validated configs for HTTP, Enrich, and Kafka integrations.
 - **WebAssembly Support:** Run rules in the browser with `@goplasmatic/dataflow-wasm`.
 - **React UI Components:** Visualize and debug rules with `@goplasmatic/dataflow-ui`.
 - **Auditing:** Full audit trail of all changes as data flows through the pipeline.
@@ -200,9 +205,104 @@ let engine = Engine::new(workflows, Some(custom_functions));
 | `parse_xml` | Parse XML string into JSON data structure | Yes |
 | `map` | Data transformation using JSONLogic | Yes |
 | `validation` | Rule-based data validation | No (read-only) |
+| `filter` | Pipeline control flow — halt workflow or skip task | No |
+| `log` | Structured logging with JSONLogic expressions | No |
 | `publish_json` | Serialize data to JSON string | Yes |
 | `publish_xml` | Serialize data to XML string | Yes |
 
+### Filter (Pipeline Control Flow)
+
+The `filter` function evaluates a JSONLogic condition and controls pipeline execution:
+
+```json
+{
+    "function": {
+        "name": "filter",
+        "input": {
+            "condition": {"==": [{"var": "data.status"}, "active"]},
+            "on_reject": "halt"
+        }
+    }
+}
+```
+
+- `on_reject: "halt"` — stops the entire workflow when the condition is false
+- `on_reject: "skip"` — skips just the current task and continues
+
+### Log (Structured Logging)
+
+The `log` function outputs structured log messages using the `log` crate:
+
+```json
+{
+    "function": {
+        "name": "log",
+        "input": {
+            "level": "info",
+            "message": {"cat": ["Processing order ", {"var": "data.order.id"}]},
+            "fields": {
+                "total": {"var": "data.order.total"},
+                "user": {"var": "data.user.name"}
+            }
+        }
+    }
+}
+```
+
+Log levels: `trace`, `debug`, `info`, `warn`, `error`. Messages and fields support JSONLogic expressions.
+
+## Channel Routing
+
+Route messages to specific workflow channels for efficient O(1) dispatch:
+
+```rust
+// Workflows define their channel
+// { "id": "order_rule", "channel": "orders", "status": "active", ... }
+
+// Process only workflows on a specific channel
+engine.process_message_for_channel("orders", &mut message).await?;
+```
+
+Only `active` workflows are included in channel routing. Workflows default to the `"default"` channel.
+
+## Workflow Lifecycle
+
+Workflows support lifecycle management fields:
+
+```json
+{
+    "id": "my_rule",
+    "channel": "orders",
+    "version": 2,
+    "status": "active",
+    "tags": ["premium", "high-priority"],
+    "created_at": "2025-01-15T10:00:00Z",
+    "updated_at": "2025-06-01T14:30:00Z",
+    "tasks": [...]
+}
+```
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `channel` | string | `"default"` | Channel for message routing |
+| `version` | number | `1` | Workflow version |
+| `status` | string | `"active"` | `active`, `paused`, or `archived` |
+| `tags` | array | `[]` | Arbitrary tags for organization |
+| `created_at` | datetime | `null` | Creation timestamp (ISO 8601) |
+| `updated_at` | datetime | `null` | Last update timestamp (ISO 8601) |
+
+All fields are optional and backward-compatible with existing configurations.
+
+## Engine Hot Reload
+
+Swap workflows at runtime without losing custom function registrations:
+
+```rust
+let new_workflows = vec![Workflow::from_json(r#"{ ... }"#)?];
+let new_engine = engine.with_new_workflows(new_workflows);
+// Old engine remains valid for in-flight messages
+```
+
 ## Related Packages
 
 | Package | Description |

docs/src/SUMMARY.md

@@ -24,6 +24,8 @@
 - [Parse](./built-in-functions/parse.md)
 - [Map](./built-in-functions/map.md)
 - [Validation](./built-in-functions/validation.md)
+- [Filter](./built-in-functions/filter.md)
+- [Log](./built-in-functions/log.md)
 - [Publish](./built-in-functions/publish.md)
 
 # JavaScript/TypeScript

docs/src/api/reference.md

@@ -42,8 +42,20 @@ pub async fn process_message(&self, message: &mut Message) -> Result<()>
 // Process with execution trace for debugging
 pub async fn process_message_with_trace(&self, message: &mut Message) -> Result<ExecutionTrace>
 
-// Get registered rules
-pub fn workflows(&self) -> &HashMap<String, Workflow>
+// Process only workflows on a specific channel (O(1) lookup)
+pub async fn process_message_for_channel(&self, channel: &str, message: &mut Message) -> Result<()>
+
+// Channel routing with execution trace
+pub async fn process_message_for_channel_with_trace(&self, channel: &str, message: &mut Message) -> Result<ExecutionTrace>
+
+// Get registered rules (sorted by priority)
+pub fn workflows(&self) -> &Arc<Vec<Workflow>>
+
+// Find a workflow by ID
+pub fn workflow_by_id(&self, id: &str) -> Option<&Workflow>
+
+// Create a new engine with different workflows, preserving custom functions
+pub fn with_new_workflows(&self, workflows: Vec<Workflow>) -> Self
 ```
 
 ## Workflow (Rule)
@@ -76,7 +88,13 @@ pub fn rule(id: &str, name: &str, condition: Value, tasks: Vec<Task>) -> Self
     "priority": "number (optional, default: 0)",
     "condition": "JSONLogic (optional, evaluated against full context)",
     "continue_on_error": "boolean (optional, default: false)",
-    "tasks": "array of Task (required)"
+    "tasks": "array of Task (required)",
+    "channel": "string (optional, default: 'default')",
+    "version": "number (optional, default: 1)",
+    "status": "'active' | 'paused' | 'archived' (optional, default: 'active')",
+    "tags": "array of string (optional, default: [])",
+    "created_at": "ISO 8601 datetime (optional)",
+    "updated_at": "ISO 8601 datetime (optional)"
 }
 ```
 
@@ -246,6 +264,24 @@ pub enum DataflowError {
 }
 ```
 
+## WorkflowStatus
+
+Lifecycle status for workflows.
+
+```rust
+use dataflow_rs::WorkflowStatus;
+```
+
+### Variants
+
+```rust
+pub enum WorkflowStatus {
+    Active,    // Default — workflow executes normally
+    Paused,    // Excluded from channel routing
+    Archived,  // Permanently retired
+}
+```
+
 ## Built-in Functions
 
 ### map
@@ -284,6 +320,41 @@ Rule-based data validation.
 }
 ```
 
+### filter
+
+Pipeline control flow — halt workflow or skip task.
+
+```json
+{
+    "name": "filter",
+    "input": {
+        "condition": "JSONLogic expression",
+        "on_reject": "halt | skip (default: halt)"
+    }
+}
+```
+
+Status codes: 200 (pass), 298 (skip), 299 (halt).
+
+### log
+
+Structured logging with JSONLogic expressions.
+
+```json
+{
+    "name": "log",
+    "input": {
+        "level": "trace | debug | info | warn | error (default: info)",
+        "message": "JSONLogic expression",
+        "fields": {
+            "key": "JSONLogic expression"
+        }
+    }
+}
+```
+
+Always returns (200, []) — never modifies the message.
+
 ## WASM API (dataflow-wasm)
 
 For browser/JavaScript usage.