@prsm/realtime 1.0.0 → 1.0.2

package/README.md

@@ -0,0 +1,9 @@
+<p align="center">
+  <img src=".github/logo.svg" width="80" height="80" alt="realtime logo">
+</p>
+
+<h1 align="center">@prsm/realtime</h1>
+
+A distributed WebSocket framework for real-time applications.
+
+Realtime coordinates connections, rooms, presence, and shared state across distributed instances using Redis - with built-in support for structured commands, presence tracking, versioned data sync, pub/sub channels, collections, persistence, and automatic reconnection.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prsm/realtime",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Distributed WebSocket framework with Redis-backed rooms, records, presence, channels, collections, and persistence",
   "type": "module",
   "license": "ISC",
@@ -8,8 +8,7 @@
     ".": "./src/index.js",
     "./client": "./src/client/index.js",
     "./sqlite": "./src/adapters/sqlite.js",
-    "./postgres": "./src/adapters/postgres.js",
-    "./devtools": "./src/devtools/index.js"
+    "./postgres": "./src/adapters/postgres.js"
   },
   "files": [
     "src"
@@ -27,14 +26,10 @@
     "ws": "^8.18.0"
   },
   "peerDependencies": {
-    "express": "^4.0.0 || ^5.0.0",
     "pg": "^8.0.0",
     "sqlite3": "^5.0.0"
   },
   "peerDependenciesMeta": {
-    "express": {
-      "optional": true
-    },
     "sqlite3": {
       "optional": true
     },

package/src/adapters/postgres.js

@@ -5,9 +5,9 @@ export function createPostgresAdapter(options = {}) {
   const opts = {
     host: "localhost",
     port: 5432,
-    database: "mesh_test",
-    user: "mesh",
-    password: "mesh_password",
+    database: "realtime_test",
+    user: "realtime",
+    password: "realtime_password",
     max: 10,
     ...options,
   }

package/src/client/client.js

@@ -169,10 +169,10 @@ export class RealtimeClient extends EventEmitter {
   async getConnectionMetadata(connectionId) {
     try {
       if (connectionId) {
-        const result = await this.command("mesh/get-connection-metadata", { connectionId })
+        const result = await this.command("rt/get-connection-metadata", { connectionId })
         return result.metadata
       }
-      const result = await this.command("mesh/get-my-connection-metadata")
+      const result = await this.command("rt/get-my-connection-metadata")
       return result.metadata
     } catch (error) {
       clientLogger.error(`Failed to get metadata for connection:`, error)
@@ -187,7 +187,7 @@ export class RealtimeClient extends EventEmitter {
    */
   async setConnectionMetadata(metadata, options) {
     try {
-      const result = await this.command("mesh/set-my-connection-metadata", { metadata, options })
+      const result = await this.command("rt/set-my-connection-metadata", { metadata, options })
       return result.success
     } catch (error) {
       clientLogger.error(`Failed to set metadata for connection:`, error)
@@ -199,11 +199,11 @@ export class RealtimeClient extends EventEmitter {
     this.connection.on("message", (data) => {
       this.emit("message", data)
 
-      if (data.command === "mesh/record-update") this._records.handleUpdate(data.payload)
-      else if (data.command === "mesh/record-deleted") this._records.handleDeleted(data.payload)
-      else if (data.command === "mesh/presence-update") this._presence.handleUpdate(data.payload)
-      else if (data.command === "mesh/subscription-message") this._channels.handleMessage(data.payload)
-      else if (data.command === "mesh/collection-diff") this._collections.handleDiff(data.payload)
+      if (data.command === "rt/record-update") this._records.handleUpdate(data.payload)
+      else if (data.command === "rt/record-deleted") this._records.handleDeleted(data.payload)
+      else if (data.command === "rt/presence-update") this._presence.handleUpdate(data.payload)
+      else if (data.command === "rt/subscription-message") this._channels.handleMessage(data.payload)
+      else if (data.command === "rt/collection-diff") this._collections.handleDiff(data.payload)
       else {
         const systemCommands = ["ping", "pong", "latency", "latency:request", "latency:response"]
         if (data.command && !systemCommands.includes(data.command)) {
@@ -238,7 +238,7 @@ export class RealtimeClient extends EventEmitter {
             this._lastActivityTime = Date.now()
             if (eventName === "visibilitychange" && doc.visibilityState === "visible") {
               if (this._status === Status.OFFLINE) return
-              this.command("mesh/noop", {}, 5000)
+              this.command("rt/noop", {}, 5000)
                 .then(() => { clientLogger.info("Tab visible, connection ok"); this.emit("republish") })
                 .catch(() => { clientLogger.info("Tab visible, forcing reconnect"); this._forceReconnect() })
             }
@@ -253,7 +253,7 @@ export class RealtimeClient extends EventEmitter {
     const now = Date.now()
     const timeSinceActivity = now - this._lastActivityTime
     if (timeSinceActivity > this.options.pingTimeout && this._status === Status.ONLINE) {
-      this.command("mesh/noop", {}, 5000).catch(() => {
+      this.command("rt/noop", {}, 5000).catch(() => {
         clientLogger.info(`No activity for ${timeSinceActivity}ms, forcing reconnect`)
         this._forceReconnect()
       })

package/src/client/connection.js

@@ -91,7 +91,7 @@ export class Connection extends EventEmitter {
 
         this.emit("message", data);
 
-        if (data.command === "mesh/assign-id") {
+        if (data.command === "rt/assign-id") {
           this.connectionId = data.payload;
           this.emit("id-assigned", data.payload);
         } else if (data.command === "latency:request") {

package/src/client/subscriptions/channels.js

@@ -23,7 +23,7 @@ export function createChannelSubscriptions(client) {
    */
   async function subscribe(channel, callback, options) {
     subscriptions.set(channel, { callback, historyLimit: options?.historyLimit })
-    const result = await client.command("mesh/subscribe-channel", {
+    const result = await client.command("rt/subscribe-channel", {
       channel,
       historyLimit: options?.historyLimit,
       since: options?.since,
@@ -40,7 +40,7 @@ export function createChannelSubscriptions(client) {
    */
   function unsubscribe(channel) {
     subscriptions.delete(channel)
-    return client.command("mesh/unsubscribe-channel", { channel })
+    return client.command("rt/unsubscribe-channel", { channel })
   }
 
   /**
@@ -50,7 +50,7 @@ export function createChannelSubscriptions(client) {
    */
   async function getHistory(channel, options) {
     try {
-      const result = await client.command("mesh/get-channel-history", {
+      const result = await client.command("rt/get-channel-history", {
         channel,
         limit: options?.limit,
         since: options?.since,

package/src/client/subscriptions/collections.js

@@ -42,7 +42,7 @@ export function createCollectionSubscriptions(client) {
    */
   async function subscribe(collectionId, options = {}) {
     try {
-      const result = await client.command("mesh/subscribe-collection", { collectionId })
+      const result = await client.command("rt/subscribe-collection", { collectionId })
       if (result.success) {
         subscriptions.set(collectionId, {
           ids: new Set(result.ids),
@@ -70,7 +70,7 @@ export function createCollectionSubscriptions(client) {
    */
   async function unsubscribe(collectionId) {
     try {
-      const success = await client.command("mesh/unsubscribe-collection", { collectionId })
+      const success = await client.command("rt/unsubscribe-collection", { collectionId })
       if (success) subscriptions.delete(collectionId)
       return success
     } catch (error) {

package/src/client/subscriptions/presence.js

@@ -16,7 +16,7 @@ export function createPresenceSubscriptions(client) {
    */
   async function subscribe(roomName, callback) {
     try {
-      const result = await client.command("mesh/subscribe-presence", { roomName })
+      const result = await client.command("rt/subscribe-presence", { roomName })
       if (result.success) {
         subscriptions.set(roomName, callback)
         if (result.present && result.present.length > 0) await callback(result)
@@ -34,7 +34,7 @@ export function createPresenceSubscriptions(client) {
    */
   async function unsubscribe(roomName) {
     try {
-      const success = await client.command("mesh/unsubscribe-presence", { roomName })
+      const success = await client.command("rt/unsubscribe-presence", { roomName })
       if (success) subscriptions.delete(roomName)
       return success
     } catch (error) {
@@ -50,7 +50,7 @@ export function createPresenceSubscriptions(client) {
    */
   async function publishState(roomName, options) {
     try {
-      return await client.command("mesh/publish-presence-state", {
+      return await client.command("rt/publish-presence-state", {
         roomName,
         state: options.state,
         expireAfter: options.expireAfter,
@@ -68,7 +68,7 @@ export function createPresenceSubscriptions(client) {
    */
   async function clearState(roomName) {
     try {
-      return await client.command("mesh/clear-presence-state", { roomName })
+      return await client.command("rt/clear-presence-state", { roomName })
     } catch (error) {
       clientLogger.error(`Failed to clear presence state for room ${roomName}:`, error)
       return false
@@ -79,7 +79,7 @@ export function createPresenceSubscriptions(client) {
     try {
       const handler = subscriptions.get(roomName)
       if (!handler) return false
-      const result = await client.command("mesh/get-presence-state", { roomName }, 5000).catch((err) => {
+      const result = await client.command("rt/get-presence-state", { roomName }, 5000).catch((err) => {
         clientLogger.error(`Failed to get presence state for room ${roomName}:`, err)
         return { success: false }
       })

package/src/client/subscriptions/records.js

@@ -63,7 +63,7 @@ export function createRecordSubscriptions(client) {
   async function subscribe(recordId, callback, options) {
     const mode = options?.mode ?? "full"
     try {
-      const result = await client.command("mesh/subscribe-record", { recordId, mode })
+      const result = await client.command("rt/subscribe-record", { recordId, mode })
       if (result.success) {
         subscriptions.set(recordId, { callback, localVersion: result.version, mode })
         if (callback) await callback({ recordId, full: result.record, version: result.version })
@@ -81,7 +81,7 @@ export function createRecordSubscriptions(client) {
    */
   async function unsubscribe(recordId) {
     try {
-      const success = await client.command("mesh/unsubscribe-record", { recordId })
+      const success = await client.command("rt/unsubscribe-record", { recordId })
       if (success) subscriptions.delete(recordId)
       return success
     } catch (error) {
@@ -98,7 +98,7 @@ export function createRecordSubscriptions(client) {
    */
   async function write(recordId, newValue, options) {
     try {
-      const result = await client.command("mesh/publish-record-update", { recordId, newValue, options })
+      const result = await client.command("rt/publish-record-update", { recordId, newValue, options })
       return result.success === true
     } catch (error) {
       clientLogger.error(`Failed to publish update for record ${recordId}:`, error)

package/src/client/subscriptions/rooms.js

@@ -9,7 +9,7 @@ export function createRoomSubscriptions(client, presence) {
    * @returns {Promise<{success: boolean, present: string[]}>}
    */
   async function join(roomName, onPresenceUpdate) {
-    const joinResult = await client.command("mesh/join-room", { roomName })
+    const joinResult = await client.command("rt/join-room", { roomName })
     if (!joinResult.success) return { success: false, present: [] }
 
     joinedRooms.set(roomName, onPresenceUpdate)
@@ -25,7 +25,7 @@ export function createRoomSubscriptions(client, presence) {
    * @returns {Promise<{success: boolean}>}
    */
   async function leave(roomName) {
-    const result = await client.command("mesh/leave-room", { roomName })
+    const result = await client.command("rt/leave-room", { roomName })
     if (result.success) {
       joinedRooms.delete(roomName)
       if (client.presenceSubscriptions.has(roomName)) {
@@ -41,7 +41,7 @@ export function createRoomSubscriptions(client, presence) {
    */
   async function getMetadata(roomName) {
     try {
-      const result = await client.command("mesh/get-room-metadata", { roomName })
+      const result = await client.command("rt/get-room-metadata", { roomName })
       return result.metadata
     } catch (error) {
       clientLogger.error(`Failed to get metadata for room ${roomName}:`, error)

package/src/server/managers/channels.js

@@ -36,8 +36,8 @@ export class ChannelManager {
     const serialized = typeof message === "string" ? message : JSON.stringify(message)
     const parsedHistory = parseInt(history, 10)
     if (!isNaN(parsedHistory) && parsedHistory > 0) {
-      await this.pubClient.rpush(`mesh:history:${channel}`, serialized)
-      await this.pubClient.ltrim(`mesh:history:${channel}`, -parsedHistory, -1)
+      await this.pubClient.rpush(`rt:history:${channel}`, serialized)
+      await this.pubClient.ltrim(`rt:history:${channel}`, -parsedHistory, -1)
     }
     this.messageStream.publishMessage(channel, serialized, instanceId)
     await this.pubClient.publish(channel, serialized)
@@ -89,11 +89,11 @@ export class ChannelManager {
         const messages = await this.persistenceManager.getMessages(channel, since, limit)
         return messages.map((msg) => msg.message)
       } catch {
-        const historyKey = `mesh:history:${channel}`
+        const historyKey = `rt:history:${channel}`
         return this.redis.lrange(historyKey, 0, limit - 1)
       }
     }
-    const historyKey = `mesh:history:${channel}`
+    const historyKey = `rt:history:${channel}`
     return this.redis.lrange(historyKey, 0, limit - 1)
   }
 

package/src/server/managers/collections.js

@@ -38,7 +38,7 @@ export class CollectionManager {
     const ids = records.map((record) => record.id)
     const version = 1
     this.collectionSubscriptions.get(collectionId).set(connectionId, { version })
-    await this.redis.set(`mesh:collection:${collectionId}:${connectionId}`, JSON.stringify(ids))
+    await this.redis.set(`rt:collection:${collectionId}:${connectionId}`, JSON.stringify(ids))
     return { ids, records, version }
   }
 
@@ -47,7 +47,7 @@ export class CollectionManager {
     if (collectionSubs?.has(connectionId)) {
       collectionSubs.delete(connectionId)
       if (collectionSubs.size === 0) this.collectionSubscriptions.delete(collectionId)
-      await this.redis.del(`mesh:collection:${collectionId}:${connectionId}`)
+      await this.redis.del(`rt:collection:${collectionId}:${connectionId}`)
       return true
     }
     return false
@@ -55,7 +55,7 @@ export class CollectionManager {
 
   async publishRecordChange(recordId) {
     try {
-      await this.redis.publish("mesh:collection:record-change", recordId)
+      await this.redis.publish("rt:collection:record-change", recordId)
     } catch (error) {
       this.emitError(new Error(`Failed to publish record change for ${recordId}: ${error}`))
     }
@@ -69,7 +69,7 @@ export class CollectionManager {
       subscribers.delete(connectionId)
       if (subscribers.size === 0) this.collectionSubscriptions.delete(collectionId)
       cleanupPromises.push(
-        this.redis.del(`mesh:collection:${collectionId}:${connectionId}`).then(() => {}).catch((err) => {
+        this.redis.del(`rt:collection:${collectionId}:${connectionId}`).then(() => {}).catch((err) => {
           this.emitError(new Error(`Failed to clean up collection subscription for "${collectionId}": ${err}`))
         })
       )
@@ -79,7 +79,7 @@ export class CollectionManager {
 
   async listRecordsMatching(pattern, options) {
     try {
-      const recordKeyPrefix = "mesh:record:"
+      const recordKeyPrefix = "rt:record:"
       const keys = []
       let cursor = "0"
       do {

package/src/server/managers/connections.js

@@ -1,8 +1,8 @@
 import { deepMerge, isObject } from "../../shared/index.js"
 
-const CONNECTIONS_HASH_KEY = "mesh:connections"
-const CONNECTIONS_META_HASH_KEY = "mesh:connection-meta"
-const INSTANCE_CONNECTIONS_KEY_PREFIX = "mesh:connections:"
+const CONNECTIONS_HASH_KEY = "rt:connections"
+const CONNECTIONS_META_HASH_KEY = "rt:connection-meta"
+const INSTANCE_CONNECTIONS_KEY_PREFIX = "rt:connections:"
 
 export class ConnectionManager {
   constructor({ redis, instanceId, roomManager }) {

package/src/server/managers/instance.js

@@ -28,38 +28,38 @@ export class InstanceManager {
   }
 
   async _registerInstance() {
-    await this.redis.sadd("mesh:instances", this.instanceId)
+    await this.redis.sadd("rt:instances", this.instanceId)
   }
 
   async _deregisterInstance() {
-    await this.redis.srem("mesh:instances", this.instanceId)
-    await this.redis.del(`mesh:instance:${this.instanceId}:heartbeat`)
+    await this.redis.srem("rt:instances", this.instanceId)
+    await this.redis.del(`rt:instance:${this.instanceId}:heartbeat`)
   }
 
   async _updateHeartbeat() {
-    await this.redis.set(`mesh:instance:${this.instanceId}:heartbeat`, Date.now().toString(), "EX", this.heartbeatTTL)
+    await this.redis.set(`rt:instance:${this.instanceId}:heartbeat`, Date.now().toString(), "EX", this.heartbeatTTL)
   }
 
   async _acquireCleanupLock() {
-    const result = await this.redis.set("mesh:cleanup:lock", this.instanceId, "EX", this.cleanupLockTTL, "NX")
+    const result = await this.redis.set("rt:cleanup:lock", this.instanceId, "EX", this.cleanupLockTTL, "NX")
     return result === "OK"
   }
 
   async _releaseCleanupLock() {
     const script = 'if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end'
-    await this.redis.eval(script, 1, "mesh:cleanup:lock", this.instanceId)
+    await this.redis.eval(script, 1, "rt:cleanup:lock", this.instanceId)
   }
 
   async _performCleanup() {
     try {
       const lockAcquired = await this._acquireCleanupLock()
       if (!lockAcquired) return
-      const registeredInstances = await this.redis.smembers("mesh:instances")
-      const allConnections = await this.redis.hgetall("mesh:connections")
+      const registeredInstances = await this.redis.smembers("rt:instances")
+      const allConnections = await this.redis.hgetall("rt:connections")
       const instanceIds = new Set([...registeredInstances, ...Object.values(allConnections)])
       for (const instanceId of instanceIds) {
         if (instanceId === this.instanceId) continue
-        const heartbeat = await this.redis.get(`mesh:instance:${instanceId}:heartbeat`)
+        const heartbeat = await this.redis.get(`rt:instance:${instanceId}:heartbeat`)
         if (!heartbeat) {
           serverLogger.info(`Found dead instance: ${instanceId}`)
           await this._cleanupDeadInstance(instanceId)
@@ -74,16 +74,16 @@ export class InstanceManager {
 
   async _cleanupDeadInstance(instanceId) {
     try {
-      const connectionsKey = `mesh:connections:${instanceId}`
+      const connectionsKey = `rt:connections:${instanceId}`
       const connections = await this.redis.smembers(connectionsKey)
       for (const connectionId of connections) {
         await this._cleanupConnection(connectionId)
       }
-      const allConnections = await this.redis.hgetall("mesh:connections")
+      const allConnections = await this.redis.hgetall("rt:connections")
       for (const [connectionId, connInstanceId] of Object.entries(allConnections)) {
         if (connInstanceId === instanceId) await this._cleanupConnection(connectionId)
       }
-      await this.redis.srem("mesh:instances", instanceId)
+      await this.redis.srem("rt:instances", instanceId)
       await this.redis.del(connectionsKey)
       serverLogger.info(`Cleaned up dead instance: ${instanceId}`)
     } catch (error) {
@@ -103,19 +103,19 @@ export class InstanceManager {
 
   async _cleanupConnection(connectionId) {
     try {
-      const roomsKey = `mesh:connection:${connectionId}:rooms`
+      const roomsKey = `rt:connection:${connectionId}:rooms`
       const rooms = await this.redis.smembers(roomsKey)
       const pipeline = this.redis.pipeline()
       for (const room of rooms) {
-        pipeline.srem(`mesh:room:${room}`, connectionId)
-        pipeline.srem(`mesh:presence:room:${room}`, connectionId)
-        pipeline.del(`mesh:presence:room:${room}:conn:${connectionId}`)
-        pipeline.del(`mesh:presence:state:${room}:conn:${connectionId}`)
+        pipeline.srem(`rt:room:${room}`, connectionId)
+        pipeline.srem(`rt:presence:room:${room}`, connectionId)
+        pipeline.del(`rt:presence:room:${room}:conn:${connectionId}`)
+        pipeline.del(`rt:presence:state:${room}:conn:${connectionId}`)
       }
       pipeline.del(roomsKey)
-      pipeline.hdel("mesh:connections", connectionId)
-      pipeline.hdel("mesh:connection-meta", connectionId)
-      await this._deleteMatchingKeys(`mesh:collection:*:${connectionId}`)
+      pipeline.hdel("rt:connections", connectionId)
+      pipeline.hdel("rt:connection-meta", connectionId)
+      await this._deleteMatchingKeys(`rt:collection:*:${connectionId}`)
       await pipeline.exec()
       serverLogger.debug(`Cleaned up stale connection: ${connectionId}`)
     } catch (error) {

package/src/server/managers/presence.js

@@ -7,8 +7,8 @@ export class PresenceManager {
     this.redisManager = redisManager
     this.presenceExpirationEventsEnabled = enableExpirationEvents
 
-    this.PRESENCE_KEY_PATTERN = /^mesh:presence:room:(.+):conn:(.+)$/
-    this.PRESENCE_STATE_KEY_PATTERN = /^mesh:presence:state:(.+):conn:(.+)$/
+    this.PRESENCE_KEY_PATTERN = /^rt:presence:room:(.+):conn:(.+)$/
+    this.PRESENCE_STATE_KEY_PATTERN = /^rt:presence:state:(.+):conn:(.+)$/
     this.trackedRooms = []
     this.roomGuards = new Map()
     this.roomTTLs = new Map()
@@ -89,9 +89,9 @@ export class PresenceManager {
     return this.defaultTTL
   }
 
-  presenceRoomKey(roomName) { return `mesh:presence:room:${roomName}` }
-  presenceConnectionKey(roomName, connectionId) { return `mesh:presence:room:${roomName}:conn:${connectionId}` }
-  presenceStateKey(roomName, connectionId) { return `mesh:presence:state:${roomName}:conn:${connectionId}` }
+  presenceRoomKey(roomName) { return `rt:presence:room:${roomName}` }
+  presenceConnectionKey(roomName, connectionId) { return `rt:presence:room:${roomName}:conn:${connectionId}` }
+  presenceStateKey(roomName, connectionId) { return `rt:presence:state:${roomName}:conn:${connectionId}` }
 
   async markOnline(connectionId, roomName) {
     const roomKey = this.presenceRoomKey(roomName)
@@ -137,7 +137,7 @@ export class PresenceManager {
   }
 
   async _publishPresenceUpdate(roomName, connectionId, type) {
-    const channel = `mesh:presence:updates:${roomName}`
+    const channel = `rt:presence:updates:${roomName}`
     const message = JSON.stringify({ type, connectionId, roomName, timestamp: Date.now() })
     await this.redis.publish(channel, message)
   }
@@ -192,7 +192,7 @@ export class PresenceManager {
   }
 
   async _publishPresenceStateUpdate(roomName, connectionId, state) {
-    const channel = `mesh:presence:updates:${roomName}`
+    const channel = `rt:presence:updates:${roomName}`
     const message = JSON.stringify({ type: "state", connectionId, roomName, state, timestamp: Date.now() })
     await this.redis.publish(channel, message)
   }

package/src/server/managers/pubsub.js

@@ -23,8 +23,8 @@ export class PubSubManager {
   subscribeToInstanceChannel() {
     const channel = `${PUB_SUB_CHANNEL_PREFIX}${this.instanceId}`
     this._subscriptionPromise = new Promise((resolve, reject) => {
-      this.subClient.subscribe(channel, RECORD_PUB_SUB_CHANNEL, "mesh:collection:record-change")
-      this.subClient.psubscribe("mesh:presence:updates:*", (err) => {
+      this.subClient.subscribe(channel, RECORD_PUB_SUB_CHANNEL, "rt:collection:record-change")
+      this.subClient.psubscribe("rt:presence:updates:*", (err) => {
         if (err) {
           this.emitError(new Error(`Failed to subscribe to channels/patterns: ${JSON.stringify({ cause: err })}`))
           reject(err)
@@ -43,14 +43,14 @@ export class PubSubManager {
         this._handleInstancePubSubMessage(channel, message)
       } else if (channel === RECORD_PUB_SUB_CHANNEL) {
         this._handleRecordUpdatePubSubMessage(message)
-      } else if (channel === "mesh:collection:record-change") {
+      } else if (channel === "rt:collection:record-change") {
         this._handleCollectionRecordChange(message)
       } else {
         const subscribers = this.getChannelSubscriptions(channel)
         if (subscribers) {
           for (const connection of subscribers) {
             if (!connection.isDead) {
-              connection.send({ command: "mesh/subscription-message", payload: { channel, message } })
+              connection.send({ command: "rt/subscription-message", payload: { channel, message } })
             }
           }
         }
@@ -58,14 +58,14 @@ export class PubSubManager {
     })
 
     this.subClient.on("pmessage", async (pattern, channel, message) => {
-      if (pattern === "mesh:presence:updates:*") {
+      if (pattern === "rt:presence:updates:*") {
         const subscribers = this.getChannelSubscriptions(channel)
         if (subscribers) {
           try {
             const payload = JSON.parse(message)
             subscribers.forEach((connection) => {
               if (!connection.isDead) {
-                connection.send({ command: "mesh/presence-update", payload })
+                connection.send({ command: "rt/presence-update", payload })
               } else {
                 subscribers.delete(connection)
               }
@@ -105,11 +105,11 @@ export class PubSubManager {
         const connection = this.connectionManager.getLocalConnection(connectionId)
         if (connection && !connection.isDead) {
           if (deleted) {
-            connection.send({ command: "mesh/record-deleted", payload: { recordId, version } })
+            connection.send({ command: "rt/record-deleted", payload: { recordId, version } })
           } else if (mode === "patch" && patch) {
-            connection.send({ command: "mesh/record-update", payload: { recordId, patch, version } })
+            connection.send({ command: "rt/record-update", payload: { recordId, patch, version } })
           } else if (mode === "full" && newValue !== undefined) {
-            connection.send({ command: "mesh/record-update", payload: { recordId, full: newValue, version } })
+            connection.send({ command: "rt/record-update", payload: { recordId, full: newValue, version } })
           }
         } else if (!connection || connection.isDead) {
           subscribers.delete(connectionId)
@@ -168,7 +168,7 @@ export class PubSubManager {
 
         const newRecords = await this.collectionManager.resolveCollection(collectionId, connection)
         const newRecordIds = newRecords.map((record) => record.id)
-        const previousRecordIdsKey = `mesh:collection:${collectionId}:${connectionId}`
+        const previousRecordIdsKey = `rt:collection:${collectionId}:${connectionId}`
         const previousRecordIdsStr = await this.pubClient.get(previousRecordIdsKey)
         const previousRecordIds = previousRecordIdsStr ? JSON.parse(previousRecordIdsStr) : []
 
@@ -199,7 +199,7 @@ export class PubSubManager {
           this.collectionManager.updateSubscriptionVersion(collectionId, connectionId, newCollectionVersion)
           await this.pubClient.set(previousRecordIdsKey, JSON.stringify(newRecordIds))
           connection.send({
-            command: "mesh/collection-diff",
+            command: "rt/collection-diff",
             payload: { collectionId, added, removed, version: newCollectionVersion },
           })
         }
@@ -209,7 +209,7 @@ export class PubSubManager {
             try {
               const { record, version } = await this.recordManager.getRecordAndVersion(recordId)
               if (record) {
-                connection.send({ command: "mesh/record-update", payload: { recordId, version, full: record } })
+                connection.send({ command: "rt/record-update", payload: { recordId, version, full: record } })
               }
             } catch (recordError) {
               serverLogger.info(`Record ${recordId} not found during collection update (likely deleted).`)
@@ -234,8 +234,8 @@ export class PubSubManager {
     if (this.subClient && this.subClient.status !== "end") {
       const channel = `${PUB_SUB_CHANNEL_PREFIX}${this.instanceId}`
       await Promise.all([
-        new Promise((resolve) => { this.subClient.unsubscribe(channel, RECORD_PUB_SUB_CHANNEL, "mesh:collection:record-change", () => resolve()) }),
-        new Promise((resolve) => { this.subClient.punsubscribe("mesh:presence:updates:*", () => resolve()) }),
+        new Promise((resolve) => { this.subClient.unsubscribe(channel, RECORD_PUB_SUB_CHANNEL, "rt:collection:record-change", () => resolve()) }),
+        new Promise((resolve) => { this.subClient.punsubscribe("rt:presence:updates:*", () => resolve()) }),
       ])
     }
   }

package/src/server/managers/rooms.js

@@ -5,9 +5,9 @@ export class RoomManager {
     this.redis = redis
   }
 
-  roomKey(roomName) { return `mesh:room:${roomName}` }
-  connectionsRoomKey(connectionId) { return `mesh:connection:${connectionId}:rooms` }
-  roomMetadataKey(roomName) { return `mesh:roommeta:${roomName}` }
+  roomKey(roomName) { return `rt:room:${roomName}` }
+  connectionsRoomKey(connectionId) { return `rt:connection:${connectionId}:rooms` }
+  roomMetadataKey(roomName) { return `rt:roommeta:${roomName}` }
 
   async getRoomConnectionIds(roomName) {
     return this.redis.smembers(this.roomKey(roomName))
@@ -30,8 +30,8 @@ export class RoomManager {
   }
 
   async getAllRooms() {
-    const keys = await this.redis.keys("mesh:room:*")
-    return keys.map((key) => key.replace("mesh:room:", ""))
+    const keys = await this.redis.keys("rt:room:*")
+    return keys.map((key) => key.replace("rt:room:", ""))
   }
 
   async removeFromRoom(roomName, connection) {
@@ -110,14 +110,14 @@ export class RoomManager {
   }
 
   async getAllMetadata() {
-    const keys = await this.redis.keys("mesh:roommeta:*")
+    const keys = await this.redis.keys("rt:roommeta:*")
     const result = []
     if (keys.length === 0) return result
     const pipeline = this.redis.pipeline()
     keys.forEach((key) => pipeline.hget(key, "data"))
     const results = await pipeline.exec()
     keys.forEach((key, index) => {
-      const roomName = key.replace("mesh:roommeta:", "")
+      const roomName = key.replace("rt:roommeta:", "")
       const data = results?.[index]?.[1]
       if (data) {
         try { result.push({ id: roomName, metadata: JSON.parse(data) }) }