Update README.md

README.md

@@ -1,15 +1,22 @@
-# 🧠 Actory — Typed Actor Model for Dart
+---
+license: gpl-3.0
+pretty_name: Typed Actor Model for Rust
+---
+# 🧠 Actory — Typed Actor Model for Rust
 
-`actory` is a lightweight actor framework for Dart that enables concurrent, message-driven systems with:
-- ✅ Async & sync actors
-- ✅ Isolate-based concurrency
-- ✅ Typed message passing (no `dynamic`)
-- ✅ Ask/reply (`Future`-based)
-- ✅ Supervision strategies
-- ✅ Remote actors with WebSocket clustering
-- ✅ Thread-safe data structures (SafeMap)
+`actory` is a lightweight, strongly typed actor framework for Dart that enables building concurrent, message-driven systems with:
 
-### 🚀 Basic Usage
+* ✅ Async & sync actors
+* ✅ Isolate-based concurrency
+* ✅ Typed message passing (no use of `dynamic`)
+* ✅ Ask/reply patterns with `Future`-based messaging
+* ✅ Supervision strategies for fault tolerance
+* ✅ Remote actors with WebSocket clustering support
+* ✅ Thread-safe data structures (SafeMap) for shared state
+
+---
+
+## 🚀 Basic Usage
 
 ```dart
 final system = ActorSystem();
@@ -22,14 +29,15 @@ final greeter = await system.spawn<Greet>(
 greeter.send(Greet('Alice'));
 ```
 
-### 🌐 Remote Actors
+---
+
+## 🌐 Remote Actors
 
-Actory supports distributed actor systems with remote actors across multiple nodes:
+Actory supports distributed actor systems spanning multiple nodes.
 
-#### Using RemoteActorFactory (Recommended)
+### Using `RemoteActorFactory` (Recommended)
 
 ```dart
-// Create a factory for your node
 final factory = RemoteActorFactory(
   host: 'localhost',
   port: 8080,
@@ -38,87 +46,73 @@ final factory = RemoteActorFactory(
 
 await factory.start();
 
-// Create local actors
 await factory.createLocalActor<ChatMessage>(
   'chat-actor',
   ChatActor(),
   (msg) => msg as ChatMessage,
 );
 
-// Register remote actors
 factory.registerRemoteActor('remote-chat', 'ws://localhost:8081');
 
-// Send messages (works for both local and remote)
 factory.sendMessage('chat-actor', ChatMessage('User', 'Hello!'));
 factory.sendMessage('remote-chat', ChatMessage('User', 'Hello remote!'));
 ```
 
-#### Manual Remote Actor Creation
+### Manual Remote Actor Setup
 
 ```dart
-// Create cluster node and registry
 final clusterNode = ClusterNode('localhost', 8080);
 final registry = ActorRegistry();
 
 await clusterNode.start();
 
-// Register local actor
 final localActor = await system.spawn<Message>(actor, decoder);
 registry.registerLocal('my-actor', localActor);
 
-// Register remote actor
 registry.registerRemote('remote-actor', 'ws://localhost:8081');
 
-// Get actor references
 final localRef = registry.get('my-actor');
 final remoteRef = registry.get('remote-actor'); // Returns RemoteActorRef
 
-// Send messages
 localRef?.send(message);
 remoteRef?.send(message);
 ```
 
-### 🔒 SafeMap - Thread-Safe Data Structure
+---
 
-SafeMap provides atomic operations for shared state management in concurrent actor systems:
+## 🔒 SafeMap — Thread-Safe Data Structure
 
-**Thread Safety Note**: SafeMap is designed for use within a single Dart isolate. In Dart's actor model, each actor runs in its own isolate, so SafeMap provides safety when multiple actors within the same isolate need to share state. For cross-isolate communication, use message passing through the actor system.
+`SafeMap` provides atomic and thread-safe operations on shared state **within a single Dart isolate**. Since each actor runs in its own isolate, `SafeMap` is useful for shared data inside an isolate, while cross-isolate communication should use message passing.
+
+### Usage Example
 
 ```dart
-// Create a thread-safe map
 final sharedData = SafeMap<String, String>();
 
-// Atomic operations
 sharedData.set('key', 'value');
 final value = sharedData.get('key');
 
-// Conditional operations
 final wasAdded = sharedData.putIfAbsent('key', () => 'default');
 final computed = sharedData.getOrCompute('key', () => 'computed');
 
-// Update operations
 final wasUpdated = sharedData.updateIfPresent('key', (v) => 'updated_$v');
 
-// Collection operations
 final keys = sharedData.keys;
 final values = sharedData.values;
 final entries = sharedData.entries;
 
-// Functional operations
 final filtered = sharedData.where((key, value) => key.startsWith('user_'));
 final transformed = sharedData.map((key, value) => MapEntry('new_$key', value.toUpperCase()));
 
-// Merge operations
 sharedData.merge({'key2': 'value2'});
 sharedData.mergeSafeMap(otherSafeMap);
 
-// Utility operations
 final copy = sharedData.copy();
 final regularMap = sharedData.toMap();
 sharedData.clear();
 ```
 
-#### SafeMap with Actors
+### SafeMap in an Actor
 
 ```dart
 class SharedStateActor extends Actor<dynamic> {
@@ -135,22 +129,26 @@ class SharedStateActor extends Actor<dynamic> {
 }
 ```
 
-### 📁 Examples
-
-- `/example/main.dart` - Basic actor usage
-- `/example/cluster_main.dart` - Cluster node example
-- `/example/simple_remote_actor.dart` - Simple remote actor example
-- `/example/remote_actor_example.dart` - Full remote actor demo
-- `/example/factory_remote_actor.dart` - RemoteActorFactory usage
-- `/example/safe_map_example.dart` - SafeMap usage with actors
-- `/example/safe_map_actor_example.dart` - Focused SafeMap actor demo
-
-### 🔧 Architecture
-
-- **Actor**: Message processing unit
-- **ActorSystem**: Manages actor lifecycle
-- **ClusterNode**: WebSocket-based node for distributed communication
-- **ActorRegistry**: Maps actor IDs to local/remote references
-- **RemoteActorRef**: Proxy for remote actors
-- **RemoteActorFactory**: High-level API for remote actor management
-- **SafeMap**: Thread-safe map for shared state management
+---
+
+## 📁 Examples
+
+* `/example/main.dart` — Basic actor usage
+* `/example/cluster_main.dart` — Cluster node example
+* `/example/simple_remote_actor.dart` — Simple remote actor
+* `/example/remote_actor_example.dart` — Full remote actor demo
+* `/example/factory_remote_actor.dart` — `RemoteActorFactory` usage
+* `/example/safe_map_example.dart` — SafeMap usage with actors
+* `/example/safe_map_actor_example.dart` — Focused SafeMap actor demo
+
+---
+
+## 🔧 Architecture Overview
+
+* **Actor** — Basic message processing unit
+* **ActorSystem** — Manages actor lifecycle and supervision
+* **ClusterNode** — WebSocket-based cluster node for distributed communication
+* **ActorRegistry** — Maps actor IDs to local or remote references
+* **RemoteActorRef** — Proxy to communicate with remote actors
+* **RemoteActorFactory** — High-level API to manage local and remote actors
+* **SafeMap** — Thread-safe map implementation for shared state within isolates