Create README.md

README.md

@@ -0,0 +1,156 @@
+# 🧠 Actory — Typed Actor Model for Dart
+
+`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)
+
+### 🚀 Basic Usage
+
+```dart
+final system = ActorSystem();
+
+final greeter = await system.spawn<Greet>(
+  Greeter(),
+  (msg) => msg as Greet,
+);
+
+greeter.send(Greet('Alice'));
+```
+
+### 🌐 Remote Actors
+
+Actory supports distributed actor systems with remote actors across multiple nodes:
+
+#### Using RemoteActorFactory (Recommended)
+
+```dart
+// Create a factory for your node
+final factory = RemoteActorFactory(
+  host: 'localhost',
+  port: 8080,
+  peerUrls: ['ws://localhost:8081'],
+);
+
+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
+
+```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:
+
+**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.
+
+```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
+
+```dart
+class SharedStateActor extends Actor<dynamic> {
+  final SafeMap<String, int> _counters = SafeMap<String, int>();
+  
+  @override
+  Future<void> onMessage(dynamic message, ActorContext<dynamic> context) async {
+    if (message is IncrementCounter) {
+      final current = _counters.get(message.key) ?? 0;
+      _counters.set(message.key, current + 1);
+      context.send('Counter ${message.key}: ${current + 1}');
+    }
+  }
+}
+```
+
+### 📁 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