verani 0.8.2 → 0.9.0

package/README.md

@@ -4,140 +4,160 @@
 
 [![MADE BY #V0ID](https://img.shields.io/badge/MADE%20BY%20%23V0ID-F3EEE1.svg?style=for-the-badge)](https://github.com/v0id-user)
 
-</div>
+Build realtime apps on Cloudflare with Socket.io-like simplicity
+
+[Getting Started](#quick-start) • [Documentation](./docs/) • [Examples](./examples/)
 
-> A simple, focused realtime SDK for Cloudflare Actors with Socket.io-like semantics
+</div>
 
-Verani brings the familiar developer experience of Socket.io to Cloudflare's Durable Objects (Actors), with proper hibernation support and minimal overhead.
+Verani brings the familiar developer experience of Socket.io to Cloudflare's Durable Objects (Actors), with proper hibernation support and minimal overhead. Build realtime chat, presence systems, notifications, and more—all running on Cloudflare's edge.
 
 ## Why Verani?
 
 - **Familiar API**: If you've used Socket.io, you already know how to use Verani
-- **Hibernation Support**: Properly handles Cloudflare Actor hibernation out of the box
-- **Type Safe**: Built with TypeScript, full type safety throughout
-- **Simple Mental Model**: Rooms, channels, and broadcast semantics that just make sense
+- **Horizontally scalable**: Per-connection architecture - each user gets their own Durable Object
+- **Hibernation support**: Handles Cloudflare Actor hibernation automatically
+- **Type safe**: Built with TypeScript, full type safety throughout
+- **Simple mental model**: Connections, rooms, and broadcast semantics that just make sense
 - **Modern DX**: Automatic reconnection, error handling, and connection lifecycle management
+- **Edge-ready**: Built for Cloudflare Workers and Durable Objects
+- **Cost-efficient**: Idle connections hibernate and cost nothing
 
 ## Quick Start
 
-### Installation
+Get a realtime chat app running in 5 minutes.
+
+### Step 1: Install
 
 ```bash
 npm install verani @cloudflare/actors
-# or
-bun add verani @cloudflare/actors
 ```
 
-### Server Side (Cloudflare Worker)
+Don't have a Cloudflare Worker project? Create one:
+
+```bash
+npm create cloudflare@latest my-verani-app
+cd my-verani-app
+npm install verani @cloudflare/actors
+```
+
+### Step 2: Create Your Connection Handler
 
-**Suggested folder structure** (optional, for clarity):
-- `src/actors/chat.actor.ts` - Room definitions
-- `src/index.ts` - Export Durable Object classes
+Create `src/actors/connection.ts`:
 
 ```typescript
-// src/actors/chat.actor.ts
-import { defineRoom, createActorHandler } from "verani";
-
-// Define your room with lifecycle hooks
-export const chatRoom = defineRoom({
-  name: "chatRoom",
-  websocketPath: "/chat",
+import { defineConnection, createConnectionHandler, createRoomHandler } from "verani";
+
+// Define connection handler (one WebSocket per user)
+const userConnection = defineConnection({
+  name: "UserConnection",
+
+  extractMeta(req) {
+    const url = new URL(req.url);
+    const userId = url.searchParams.get("userId") || crypto.randomUUID();
+    return {
+      userId,
+      clientId: crypto.randomUUID(),
+      channels: ["default"]
+    };
+  },
 
-  onConnect(ctx) {
+  async onConnect(ctx) {
     console.log(`User ${ctx.meta.userId} connected`);
-    // Use emit API (socket.io-like)
-    ctx.actor.emit.to("default").emit("user.joined", {
-      userId: ctx.meta.userId
-    });
+    // Join chat room (persisted across hibernation)
+    await ctx.actor.joinRoom("chat");
   },
 
-  onDisconnect(ctx) {
+  async onDisconnect(ctx) {
     console.log(`User ${ctx.meta.userId} disconnected`);
-    ctx.actor.emit.to("default").emit("user.left", {
-      userId: ctx.meta.userId
-    });
+    // Room leave is handled automatically
   }
 });
 
-// Register event handlers (socket.io-like, recommended)
-chatRoom.on("chat.message", (ctx, data) => {
-  // Broadcast to all in default channel
-  ctx.actor.emit.to("default").emit("chat.message", {
+// Handle messages (socket.io-like API)
+userConnection.on("chat.message", async (ctx, data) => {
+  // Broadcast to everyone in the chat room
+  await ctx.emit.toRoom("chat").emit("chat.message", {
     from: ctx.meta.userId,
     text: data.text,
     timestamp: Date.now()
   });
 });
 
-// Create the Durable Object class from the room definition
-// Important: Each defineRoom() creates a room definition object.
-// createActorHandler() converts it into a Durable Object class that must be exported.
-export const ChatRoom = createActorHandler(chatRoom);
+// Export the connection handler
+export const UserConnection = createConnectionHandler(userConnection);
+
+// Export the room coordinator
+export const ChatRoom = createRoomHandler({ name: "ChatRoom" });
 ```
 
+### Step 3: Wire Up Your Worker
+
+Update `src/index.ts`:
+
 ```typescript
-// src/index.ts
-import { createActorHandler } from "verani";
-import { chatRoom } from "./actors/chat.actor";
+import { UserConnection, ChatRoom } from "./actors/connection";
 
-// Create and export the Durable Object class
-export const ChatRoom = createActorHandler(chatRoom);
-```
+// Export Durable Object classes
+export { UserConnection, ChatRoom };
 
-### Wrangler Configuration
+// Route WebSocket connections
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    const url = new URL(request.url);
 
-**Critical**: Each `defineRoom()` creates a room definition, and `createActorHandler()` converts it into a Durable Object class. This class **must be exported** and **declared in Wrangler configuration**.
+    if (url.pathname.startsWith("/ws")) {
+      // Extract userId and route to user-specific DO
+      const userId = url.searchParams.get("userId") || crypto.randomUUID();
+      const stub = UserConnection.get(userId);
+      return stub.fetch(request);
+    }
+
+    return new Response("Not Found", { status: 404 });
+  }
+};
+```
 
-The export name in `src/index.ts` **must match** the `class_name` in `wrangler.jsonc`:
+### Step 4: Configure Wrangler
+
+Update `wrangler.jsonc`:
 
 ```jsonc
 {
+  "name": "my-verani-app",
+  "main": "src/index.ts",
+  "compatibility_date": "2024-01-01",
+
   "durable_objects": {
     "bindings": [
       {
-        "class_name": "ChatRoom",  // Must match export name
-        "name": "ChatRoom"              // Binding name in env
+        "class_name": "UserConnection",
+        "name": "CONNECTION_DO"
+      },
+      {
+        "class_name": "ChatRoom",
+        "name": "ROOM_DO"
       }
     ]
   },
+
   "migrations": [
     {
-      "new_sqlite_classes": ["ChatRoom"],
+      "new_sqlite_classes": ["UserConnection", "ChatRoom"],
       "tag": "v1"
     }
   ]
 }
 ```
 
-**Three-way relationship** - these must all align:
+Important: Export names must match `class_name` in `wrangler.jsonc`.
 
-1. **Room definition**: `defineRoom({ name: "ChatRoom" })` - The `name` property is optional but recommended for consistency
-2. **Export** in `src/index.ts`: `export const ChatRoom = createActorHandler(chatRoom)` - The export name becomes the class name
-3. **Class name** in `wrangler.jsonc`: `"class_name": "ChatRoom"` - Must match the export name exactly
-
-**Important Notes:**
-- `defineRoom()` returns a room definition object, **not** a Durable Object class
-- `createActorHandler(room)` creates the actual Durable Object class
-- Each room definition must be converted to a class with `createActorHandler()` and exported
-- For multiple rooms, you need multiple exports and multiple bindings in `wrangler.jsonc`
-- The export name (e.g., `ChatRoom`) becomes the class name and must match `class_name` in configuration
-
-### Client Side
+### Step 5: Build Your Client
 
 ```typescript
-import { VeraniClient } from "verani";
-
-// Connect to your Cloudflare Worker with ping/pong keepalive
-const client = new VeraniClient("wss://your-worker.dev/ws?userId=alice", {
-  pingInterval: 5000,  // Send ping every 5 seconds
-  pongTimeout: 5000,  // Expect pong within 5 seconds
-  reconnection: {
-    enabled: true,
-    maxAttempts: 10,
-    initialDelay: 1000,
-    maxDelay: 30000
-  }
-});
+import { VeraniClient } from "verani/client";
+
+const client = new VeraniClient("ws://localhost:8787/ws?userId=alice");
 
 // Listen for messages
 client.on("chat.message", (data) => {
@@ -145,153 +165,97 @@ client.on("chat.message", (data) => {
 });
 
 client.on("user.joined", (data) => {
-  console.log(`User ${data.userId} joined`);
+  console.log(`User ${data.userId} joined!`);
 });
 
 // Send messages
 client.emit("chat.message", { text: "Hello, world!" });
 
-// Handle connection lifecycle
-client.onOpen(() => {
-  console.log("Connected!");
-});
-
-client.onStateChange((state) => {
-  console.log("Connection state:", state);
-});
-
-// Wait for connection before sending
+// Wait for connection (optional)
 await client.waitForConnection();
-client.emit("ready", {});
 ```
 
-## Key Concepts
-
-### Actors = Rooms
-
-Each Cloudflare Actor instance represents a **logical container** for realtime communication:
-
-- **Chat room**: All users in the same chat share one Actor
-- **User notifications**: Each user gets their own Actor
-- **Game session**: Each game instance is one Actor
-
-### Channels
-
-Inside an Actor, connections can join **channels** for selective message routing:
+### Step 6: Run It!
 
-```typescript
-// Server: broadcast to specific channel using emit API
-ctx.actor.emit.to("game-updates").emit("update", data);
-
-// Or send to a specific user (all their sessions)
-ctx.emit.to("alice").emit("notification", { message: "Hello!" });
+```bash
+# Start the server
+npm run dev
+# or
+wrangler dev
 
-// Client: joins "default" channel automatically
-// You can implement join/leave for custom channels
+# In another terminal, run your client
+# (or open multiple browser tabs with your client code)
 ```
 
-### Hibernation
+That's it! You now have a working realtime chat app.
 
-Verani handles Cloudflare's hibernation automatically:
-
-- Connection metadata survives hibernation via WebSocket attachments
-- Sessions are restored when the Actor wakes up
-- No manual state management needed
+Need more help? Check out the [Quick Start Guide](./docs/getting-started/quick-start.md) for detailed examples.
 
 ## Documentation
 
-- **[Getting Started](./docs/getting-started/)** - Installation and quick start guide
-- **[API Reference](./docs/api/)** - Complete server and client API documentation
-- **[Guides](./docs/guides/)** - Configuration, deployment, scaling, and RPC
-- **[Examples](./docs/examples/)** - Common usage patterns and code samples
-- **[Concepts](./docs/concepts/)** - Architecture, hibernation, and core concepts
-- **[Security](./docs/security/)** - Authentication, authorization, and best practices
-
-## More Examples
-**[Vchats](https://github.com/v0id-user/vchats)** - A simple chat application built with Verani
-
-## Features
+- [Live Documentation](https://verani-docs.cloudflare-c49.workers.dev/docs/getting-started/installation) - Installation and quick start guide
+- [Getting Started](./docs/getting-started/) - Installation and quick start guide
+- [API Reference](./docs/api/) - Complete server and client API documentation
+- [Guides](./docs/guides/) - Configuration, deployment, scaling, and RPC
+- [Examples](./docs/examples/) - Common usage patterns and code samples
+- [Concepts](./docs/concepts/) - Architecture, hibernation, and core concepts
+- [Security](./docs/security/) - Authentication, authorization, and best practices
 
-### Server (Actor) Side
-
-- **Socket.io-like event handlers** - `room.on()` and `room.off()` for clean event handling
-- **Emit API** - `ctx.emit` and `ctx.actor.emit.to()` for intuitive message sending
-- Room-based architecture with lifecycle hooks (`onConnect`, `onDisconnect`, `onHibernationRestore`)
-- WebSocket attachment management for hibernation
-- Selective broadcasting with filters (userIds, clientIds, except)
-- User and client ID tracking
-- **RPC methods** - Call Actor methods remotely from Workers or other Actors
-- Durable Object storage access for persistent state
-- Error boundaries and logging
-- Flexible metadata extraction from requests
-
-### Client Side
+## Key Concepts
 
-- Automatic reconnection with exponential backoff
-- Connection state management (`getState()`, `getConnectionState()`, `isConnecting`)
-- Message queueing when disconnected
-- Event-based API (on/off/once/emit)
-- Promise-based connection waiting (`waitForConnection()`)
-- Lifecycle callbacks (`onOpen`, `onClose`, `onError`, `onStateChange`)
-- **Ping/pong keepalive** with automatic Page Visibility API resync
-- Configurable connection timeout and queue size
+- **ConnectionDO** = A Durable Object that owns ONE WebSocket per user
+- **RoomDO** = A Durable Object that coordinates room membership and broadcasts
+- **Emit** = Send messages (`ctx.emit.toRoom("chat").emit("event", data)`)
+- **Hibernation** = Handled automatically, state persisted and restored
 
-### RPC Support
+## Features
 
-Call Actor methods remotely from Workers or other Actors:
+### Server-Side
+- **Per-connection DOs**: Each user gets their own Durable Object (horizontally scalable)
+- **Socket.io-like API**: `connection.on()`, `ctx.emit.toRoom()`, familiar patterns
+- **Room coordination**: RoomDOs manage membership and broadcast via RPC
+- **Lifecycle hooks**: `onConnect`, `onDisconnect`, `onMessage` for full control
+- **RPC support**: DO-to-DO communication for message delivery
+- **Automatic hibernation**: State persisted and restored automatically
+- **Persistent state**: Built-in support for state that survives hibernation
+- **Type safety**: Full TypeScript support with type inference
 
-```typescript
-// In your Worker fetch handler
-const stub = ChatRoom.get("room-id");
+### Client-Side
+- **Automatic reconnection**: Exponential backoff with configurable retry logic
+- **Message queueing**: Messages queued when disconnected, sent on reconnect
+- **Keepalive**: Built-in ping/pong to detect dead connections
+- **Event-based API**: Familiar `on()`, `emit()`, `once()`, `off()` methods
+- **Connection state**: Track connection lifecycle (`connecting`, `connected`, `disconnected`)
 
-// Send to user
-await stub.sendToUser("alice", "notifications", {
-  type: "alert",
-  message: "You have a new message"
-});
+## Try the Examples
 
-// Broadcast to channel
-await stub.broadcast("default", { type: "announcement", text: "Hello!" });
+See Verani in action with working examples:
 
-// Query state
-const count = await stub.getSessionCount();
-const userIds = await stub.getConnectedUserIds();
+```bash
+git clone https://github.com/v0id-user/verani
+cd verani
+bun install && bun run dev
 ```
 
-- Send messages to users from HTTP endpoints
-- Query actor state remotely
-- Broadcast from external events or scheduled tasks
-- Coordinate between multiple Actors
-
-## Live Examples
-
-Try out Verani with working examples:
+Then in another terminal, try:
 
 ```bash
-# Clone and run
-git clone https://github.com/v0id-user/verani
-cd verani
-bun install  # or npm install
-bun run dev  # or npm run dev
+# Chat room example
+bun run examples/clients/chat-client.ts
 
-# Open http://localhost:8787
-```
+# Presence tracking
+bun run examples/clients/presence-client.ts
 
-See `examples/` for chat, presence, and notifications demos!
+# Notifications feed
+bun run examples/clients/notifications-client.ts
+```
 
-## Project Status
+See the [Examples README](./examples/README.md) for more details.
 
-Verani is in early stages and active development. Current version includes:
+## Real-World Example
 
-**Implemented:**
-- Core realtime messaging
-- Hibernation support
-- Client reconnection
-- Presence protocol with multi-device support
-- Persistent storage integration with Durable Object storage
+[Vchats](https://github.com/v0id-user/vchats) - A complete chat application built with Verani
 
-**Coming Soon:**
-- React/framework adapters
 
 ## License
 
@@ -299,5 +263,5 @@ ISC
 
 ## Contributing
 
-Contributions welcome! Please read our contributing guidelines first.
+Contributions welcome! Please read our [Contributing Guidelines](./CONTRIBUTING.md) first.
 

package/dist/actor-runtime-83AF97II.mjs

@@ -0,0 +1 @@
+import{a as decodeFrame$1,n as encodeFrame$1}from"./encode-BhJqnsto.mjs";import{Actor}from"@cloudflare/actors";function isValidConnectionMeta(d){return!(!d||typeof d!=`object`||typeof d.userId!=`string`||!d.userId||typeof d.clientId!=`string`||!d.clientId||!Array.isArray(d.channels)||!d.channels.every(d=>typeof d==`string`))}function storeAttachment(d,F){d.serializeAttachment(F)}function restoreSessions(d){let F=0,I=0;for(let R of d.ctx.getWebSockets()){if(R.readyState!==WebSocket.OPEN){I++;continue}let z=R.deserializeAttachment();if(!z){I++;continue}if(!isValidConnectionMeta(z)){I++;continue}d.sessions.set(R,{ws:R,meta:z}),F++}}function decodeFrame(F){return decodeFrame$1(F)??{type:`invalid`}}function encodeFrame(d){return encodeFrame$1(d)}const PERSIST_ERROR_HANDLER=Symbol(`PERSIST_ERROR_HANDLER`),PERSISTED_STATE=Symbol(`PERSISTED_STATE`),STATE_READY=Symbol(`STATE_READY`);var PersistNotReadyError=class extends Error{constructor(d){super(`Cannot access persisted state key "${d}" before storage is initialized. Wait for onInit to complete or check actor.isStateReady().`),this.name=`PersistNotReadyError`}},PersistError=class extends Error{constructor(d,F){super(`Failed to persist key "${d}": ${F.message}`),this.name=`PersistError`,this.originalCause=F}};function safeSerialize(d){let F=new WeakSet;return JSON.stringify(d,(d,I)=>{if(I instanceof Date)return{__type:`Date`,value:I.toISOString()};if(I instanceof RegExp)return{__type:`RegExp`,source:I.source,flags:I.flags};if(I instanceof Map)return{__type:`Map`,entries:Array.from(I.entries())};if(I instanceof Set)return{__type:`Set`,values:Array.from(I.values())};if(I instanceof Error)return{__type:`Error`,name:I.name,message:I.message};if(typeof I==`object`&&I){if(F.has(I))return;F.add(I)}if(!(typeof I==`function`||typeof I==`symbol`))return I})}function safeDeserialize(d){return JSON.parse(d,(d,F)=>{if(F&&typeof F==`object`&&F.__type)switch(F.__type){case`Date`:return new Date(F.value);case`RegExp`:return new RegExp(F.source,F.flags);case`Map`:return new Map(F.entries);case`Set`:return new Set(F.values);case`Error`:{let d=Error(F.message);return d.name=F.name,d}}return F})}function createShallowProxy(d,F,I){return new Proxy(d,{set(d,I,L){let R=Reflect.set(d,I,L);return R&&typeof I==`string`&&F(I,L),R},deleteProperty(d,F){let L=Reflect.deleteProperty(d,F);return L&&typeof F==`string`&&I(F),L}})}async function initializePersistedState(d,F,I=[],L={}){let{shallow:R=!0,throwOnError:z=!0}=L,B=d.ctx.storage,V=I.length>0?I.map(String):Object.keys(F),W={...F};for(let d of V)try{let F=await B.get(`_verani_persist:${d}`);if(F!==void 0)try{W[d]=safeDeserialize(F)}catch(F){if(z)throw new PersistError(d,F)}}catch(F){if(z&&!(F instanceof PersistError))throw new PersistError(d,F)}let G=async(F,I)=>{if(V.includes(F))try{let d=safeSerialize(I);await B.put(`_verani_persist:${F}`,d)}catch(I){let L=d[PERSIST_ERROR_HANDLER];if(L&&L(F,I),z)throw new PersistError(F,I)}},K=async F=>{if(V.includes(F))try{await B.delete(`_verani_persist:${F}`)}catch(I){let L=d[PERSIST_ERROR_HANDLER];if(L&&L(F,I),z)throw new PersistError(F,I)}},q;return q=R?createShallowProxy(W,(d,F)=>{G(String(d),F)},d=>{K(String(d))}):createDeepProxy(W,(d,F)=>{G(d,F)},d=>{K(d)},V),d[STATE_READY]=!0,d[PERSISTED_STATE]=q,q}function createDeepProxy(d,F,I,L,R){return new Proxy(d,{get(d,z){let B=Reflect.get(d,z);if(B&&typeof B==`object`&&!Array.isArray(B)){let d=R??String(z);if(L.includes(d)||R!==void 0)return createDeepProxy(B,F,I,L,d)}return B},set(d,I,z){let B=Reflect.set(d,I,z);if(B){let d=R??String(I);L.includes(d)&&(R?F(R,void 0):F(String(I),z))}return B},deleteProperty(d,z){let B=Reflect.deleteProperty(d,z);if(B){let d=R??String(z);L.includes(d)&&(R?F(R,void 0):I(String(z)))}return B}})}function isStateReady(d){return d[STATE_READY]===!0}function getPersistedState(d){if(!isStateReady(d))throw new PersistNotReadyError(`state`);return d[PERSISTED_STATE]}function setPeristErrorHandler(d,F){d[PERSIST_ERROR_HANDLER]=F}async function persistKey(d,F,I){let L=d.ctx.storage,R=safeSerialize(I);await L.put(`_verani_persist:${F}`,R)}async function deletePersistedKey(d,F){await d.ctx.storage.delete(`_verani_persist:${F}`)}async function getPersistedKeys(d){let F=await d.ctx.storage.list({prefix:`_verani_persist:`});return Array.from(F.keys()).map(d=>d.replace(`_verani_persist:`,``))}async function clearPersistedState(d){let F=d.ctx.storage,I=await F.list({prefix:`_verani_persist:`}),L=Array.from(I.keys());await F.delete(L)}var RoomEventEmitterImpl=class{constructor(){this.handlers=new Map}on(d,F){this.handlers.has(d)||this.handlers.set(d,new Set),this.handlers.get(d).add(F)}off(d,F){let I=this.handlers.get(d);I&&(F?(I.delete(F),I.size===0&&this.handlers.delete(d)):this.handlers.delete(d))}async emit(d,F,I){let L=this.handlers.get(d);if(L&&L.size>0){let d=[];for(let R of L)try{let L=R(F,I);L instanceof Promise&&d.push(L)}catch{}await Promise.all(d)}let R=this.handlers.get(`*`);if(R&&R.size>0){let d=[];for(let L of R)try{let R=L(F,I);R instanceof Promise&&d.push(R)}catch{}await Promise.all(d)}}hasHandlers(d){return this.handlers.has(d)&&this.handlers.get(d).size>0||this.handlers.has(`*`)&&this.handlers.get(`*`).size>0}getEventNames(){return Array.from(this.handlers.keys())}rebuildHandlers(d){this.handlers.clear();for(let[F,I]of d.entries())this.handlers.set(F,new Set(I))}};function createRoomEventEmitter(){return new RoomEventEmitterImpl}function defaultExtractMeta(d){let F=crypto.randomUUID(),I=crypto.randomUUID(),L=new URL(d.url).searchParams.get(`channels`);return{userId:F,clientId:I,channels:L?L.split(`,`).map(d=>d.trim()).filter(Boolean):[`default`]}}function defineRoom(d){let F=d.eventEmitter||createRoomEventEmitter(),I=d._staticHandlers||new Map;return{name:d.name,websocketPath:d.websocketPath,extractMeta:d.extractMeta||(d=>defaultExtractMeta(d)),onConnect:d.onConnect,onDisconnect:d.onDisconnect,onMessage:d.onMessage,onError:d.onError,onHibernationRestore:d.onHibernationRestore,eventEmitter:F,_staticHandlers:I,state:d.state,persistedKeys:d.persistedKeys,persistOptions:d.persistOptions,onPersistError:d.onPersistError,on(d,L){F.on(d,L),I.has(d)||I.set(d,new Set),I.get(d).add(L)},off(d,L){F.off(d,L);let R=I.get(d);R&&(L?(R.delete(L),R.size===0&&I.delete(d)):I.delete(d))}}}function cleanupStaleSessions(d){let F=0,I=[];for(let[F,L]of d.entries())F.readyState!==WebSocket.OPEN&&I.push(F);for(let L of I)d.delete(L),F++;return F}function broadcast(d,F,I,L){let R=0,z=encodeFrame({type:`event`,channel:F,data:I}),B=[];for(let{ws:I,meta:V}of d.values())if(V.channels.includes(F)&&!(L?.except&&I===L.except)&&!(L?.userIds&&!L.userIds.includes(V.userId))&&!(L?.clientIds&&!L.clientIds.includes(V.clientId))){if(I.readyState!==WebSocket.OPEN){B.push(I);continue}try{I.send(z),R++}catch{B.push(I)}}for(let F of B)d.delete(F);return B.length,R}function sendToUser(d,F,I,L){let R=0,z=encodeFrame({type:`event`,channel:I,data:L}),B=[];for(let{ws:L,meta:V}of d.values())if(V.userId===F&&V.channels.includes(I)){if(L.readyState!==WebSocket.OPEN){B.push(L);continue}try{L.send(z),R++}catch{B.push(L)}}for(let F of B)d.delete(F);return B.length,R}function getSessionCount(d){return d.size}function getConnectedUserIds(d){let F=new Set;for(let{meta:I}of d.values())F.add(I.userId);return Array.from(F)}function getUserSessions(d,F){let I=[];for(let{ws:L,meta:R}of d.values())R.userId===F&&I.push(L);return I}function getStorage(d){return d.storage}function sanitizeToClassName(d){return d.replace(/^\/+/,``).split(/[-_\/\s]+/).map(d=>d.replace(/[^a-zA-Z0-9]/g,``)).filter(d=>d.length>0).map(d=>d.charAt(0).toUpperCase()+d.slice(1).toLowerCase()).join(``)||`VeraniActor`}function createConfiguration(d){return function(F){return{sockets:{upgradePath:d.websocketPath}}}}async function onInit(d,F){if(F.eventEmitter&&F._staticHandlers)try{F.eventEmitter.rebuildHandlers(F._staticHandlers)}catch{}try{restoreSessions(d)}catch{}if(F.onHibernationRestore&&d.sessions.size>0)try{await F.onHibernationRestore(d)}catch{}else F.onHibernationRestore&&d.sessions.size}function createUserEmitBuilder(d,F,I){return{emit(L,R){return sendToUser(F,d,I,{type:L,...R})}}}function createChannelEmitBuilder(d,F,I){return{emit(L,R){return broadcast(F,d,{type:L,...R},I)}}}function createSocketEmit(d){let F=d.meta.channels[0]||`default`;return{emit(I,L){if(d.ws.readyState===WebSocket.OPEN)try{let R={type:`event`,channel:F,data:{type:I,...L}};d.ws.send(encodeFrame(R))}catch{}},to(I){return d.meta.channels.includes(I)?createChannelEmitBuilder(I,d.actor.sessions,{except:d.ws}):createUserEmitBuilder(I,d.actor.sessions,F)}}}function createActorEmit(d){return{emit(F,I){let L={type:F,...I};return broadcast(d.sessions,`default`,L)},to(F){return createChannelEmitBuilder(F,d.sessions)}}}async function onWebSocketConnect(d,F,I,L){let z;try{if(z=F.extractMeta?await F.extractMeta(L):{userId:`anonymous`,clientId:crypto.randomUUID(),channels:[`default`]},storeAttachment(I,z),F.onConnect){let L={actor:d,ws:I,meta:z,frame:{type:`connect`}};L.emit=createSocketEmit(L);let R={actor:d,ws:I,meta:z,emit:L.emit};await F.onConnect(R)}d.sessions.set(I,{ws:I,meta:z})}catch(L){if(F.onError&&z)try{let R={actor:d,ws:I,meta:z,frame:{type:`error`}};R.emit=createSocketEmit(R),await F.onError(L,{actor:d,ws:I,meta:z,emit:R.emit})}catch{}I.close(1011,`Internal server error`)}}async function onWebSocketMessage(d,F,I,L){let R;try{let z=decodeFrame(L);if(z&&z.type===`ping`){if(I.readyState===WebSocket.OPEN)try{I.send(encodeFrame({type:`pong`}))}catch{}return}if(!z||z.type===`invalid`||(R=d.sessions.get(I),!R))return;let H={actor:d,ws:I,meta:R.meta,frame:z,emit:createSocketEmit({actor:d,ws:I,meta:R.meta,frame:z})},U=F.eventEmitter;U?.hasHandlers(z.type)?await U.emit(z.type,H,z.data||{}):F.onMessage&&await F.onMessage(H,z)}catch(L){if(F.onError&&R)try{await F.onError(L,{actor:d,ws:I,meta:R.meta,emit:createSocketEmit({actor:d,ws:I,meta:R.meta,frame:{type:`error`}})})}catch{}}}async function onWebSocketDisconnect(d,F,I){try{let L=d.sessions.get(I);if(d.sessions.delete(I),L&&F.onDisconnect){let R={actor:d,ws:I,meta:L.meta,frame:{type:`disconnect`}};R.emit=createSocketEmit(R);let z={actor:d,ws:I,meta:L.meta,emit:R.emit};await F.onDisconnect(z)}}catch{}}function createFetch(d,F){return async function(I){let L=new URL(I.url),R=I.headers.get(`Upgrade`);return L.pathname===d.websocketPath&&R===`websocket`&&await F.shouldUpgradeWebSocket(I)?F.onWebSocketUpgrade(I):F.onRequest(I)}}function createActorHandler(d){let F=sanitizeToClassName(d.name||d.websocketPath||`VeraniActor`),L=d;class R extends Actor{constructor(...F){super(...F),this.sessions=new Map,this.emit=createActorEmit(this),this[STATE_READY]=!1,this[PERSISTED_STATE]=d.state?{...d.state}:{},this.fetch=createFetch(L,this)}get roomState(){return this[PERSISTED_STATE]}isStateReady(){return isStateReady(this)}static{this.configuration=createConfiguration(L)}async shouldUpgradeWebSocket(d){return!0}async onInit(){if(d.state){d.onPersistError&&setPeristErrorHandler(this,d.onPersistError);let F=d.persistedKeys;this[PERSISTED_STATE]=await initializePersistedState(this,d.state,F,d.persistOptions)}await onInit(this,L)}async onWebSocketConnect(d,F){await onWebSocketConnect(this,L,d,F)}async onWebSocketMessage(d,F){await onWebSocketMessage(this,L,d,F)}async onWebSocketDisconnect(d){await onWebSocketDisconnect(this,L,d)}cleanupStaleSessions(){return cleanupStaleSessions(this.sessions)}broadcast(d,F,I){return broadcast(this.sessions,d,F,I)}getSessionCount(){return getSessionCount(this.sessions)}getConnectedUserIds(){return getConnectedUserIds(this.sessions)}getUserSessions(d){return getUserSessions(this.sessions,d)}sendToUser(d,F,I){return sendToUser(this.sessions,d,F,I)}emitToChannel(d,F,I){let L={type:F,...I};return broadcast(this.sessions,d,L)}emitToUser(d,F,I){let L=encodeFrame({type:`event`,channel:`default`,data:{type:F,...I}}),R=0,z=[];for(let{ws:F,meta:I}of this.sessions.values())if(I.userId===d){if(F.readyState!==WebSocket.OPEN){z.push(F);continue}try{F.send(L),R++}catch{z.push(F)}}for(let d of z)this.sessions.delete(d);return R}getStorage(){return getStorage(this.ctx)}}return Object.defineProperty(R,`name`,{value:F,writable:!1,configurable:!0}),R}export{encodeFrame as _,PersistNotReadyError as a,deletePersistedKey as c,initializePersistedState as d,isStateReady as f,setPeristErrorHandler as g,safeSerialize as h,PersistError as i,getPersistedKeys as l,safeDeserialize as m,defineRoom as n,STATE_READY as o,persistKey as p,PERSISTED_STATE as r,clearPersistedState as s,createActorHandler as t,getPersistedState as u,restoreSessions as v,storeAttachment as y};