@vuer-ai/vuer-rtc-server 0.2.3 → 0.4.1

package/src/serve.ts

@@ -2,19 +2,37 @@
  * serve.ts — HTTP + WebSocket entry point.
  *
  * Wires real WS connections to RTCServer + InMemoryBroker.
- * URL pattern: ws://localhost:{PORT}/ws/{roomId}?sessionId={sessionId}
  *
- * Also serves REST API for inspecting the MongoDB database:
+ * WebSocket URL patterns:
+ *   ws://localhost:{PORT}/ws/graph/{roomId}?client={client}
+ *   ws://localhost:{PORT}/ws/text/{docId}?client={client}
+ *
+ * REST API for inspecting the MongoDB database:
  *   GET /api/stats
- *   GET /api/documents
- *   GET /api/documents/:id
- *   GET /api/documents/:id/journal
- *   GET /api/documents/:id/operations
- *   GET /api/documents/:id/sessions
- *   GET /api/rooms/:roomId/state
- *   DELETE /api/rooms/:roomId
- *   POST /api/documents/:id/compact — trigger journal compaction
- *   POST /api/documents/:id/coalesce — operation coalescing (placeholder)
+ *
+ *   Graph Documents (Scene Graphs):
+ *   GET /api/graph
+ *   GET /api/graph/:id
+ *   GET /api/graph/:id/journal
+ *   GET /api/graph/:id/operations
+ *   GET /api/graph/:id/sessions
+ *   POST /api/graph/:id/compact
+ *   POST /api/graph/:id/coalesce
+ *   DELETE /api/graph/:id
+ *
+ *   Text Documents (Standalone Text CRDTs):
+ *   GET /api/text
+ *   GET /api/text/:id
+ *   GET /api/text/:id/journal
+ *   GET /api/text/:id/operations
+ *   GET /api/text/:id/sessions
+ *   POST /api/text/:id/compact
+ *   POST /api/text/:id/coalesce
+ *   DELETE /api/text/:id
+ *
+ *   Legacy endpoints (redirect to /api/graph/):
+ *   GET /api/documents -> /api/graph
+ *   GET /api/rooms/:roomId/state -> /api/graph/:id/state
  */
 
 import { createServer, type IncomingMessage, type ServerResponse } from 'http';
@@ -22,7 +40,7 @@ import { WebSocketServer } from 'ws';
 import { InMemoryBroker } from './broker/index.js';
 import { RTCServer } from './transport/index.js';
 import { createPrismaClient } from './persistence/PrismaClient.js';
-import { JournalService } from './journal/index.js';
+import { GraphJournalService, TextJournalService } from './journal/index.js';
 import { SessionRepository } from './persistence/SessionRepository.js';
 import { CoalescingService } from './journal/CoalescingService.js';
 
@@ -30,13 +48,14 @@ const PORT = Number(process.env.PORT) || 8080;
 const prisma = createPrismaClient();
 
 const broker = new InMemoryBroker();
-const journalService = new JournalService(prisma);
+const graphJournalService = new GraphJournalService(prisma);
+const textJournalService = new TextJournalService(prisma);
 const sessionRepo = new SessionRepository(prisma);
 const coalescingService = new CoalescingService(prisma);
 
-// Wire the broker's member clocks into the journal service so compaction
+// Wire the broker's member clocks into the graph journal service so compaction
 // only folds entries that all connected clients have acknowledged.
-journalService.setMemberClockProvider(async (docId: string) => {
+graphJournalService.setMemberClockProvider(async (docId: string) => {
   // Reverse-lookup: docId -> roomId (room name is used as document name)
   const doc = await prisma.document.findUnique({ where: { id: docId } });
   if (!doc) return [];
@@ -46,7 +65,19 @@ journalService.setMemberClockProvider(async (docId: string) => {
     .map((m) => m.vectorClock);
 });
 
-journalService.startCompactionLoop();
+// Wire the broker's member clocks into the text journal service
+textJournalService.setMemberClockProvider(async (docId: string) => {
+  // Reverse-lookup: docId -> document name
+  const doc = await prisma.textDocument.findUnique({ where: { id: docId } });
+  if (!doc) return [];
+  const members = await broker.getMembers(doc.name);
+  return Array.from(members.values())
+    .filter((m) => m.connected)
+    .map((m) => m.vectorClock);
+});
+
+graphJournalService.startCompactionLoop();
+textJournalService.startCompactionLoop();
 
 // ── Session TTL cleanup loop ──
 // Automatically removes disconnected sessions after TTL expires.
@@ -64,9 +95,9 @@ async function cleanupStaleSessions() {
     // Clean up stale sessions from broker memory
     for (const roomId of roomIds) {
       const members = await broker.getMembers(roomId);
-      for (const [sessionId, member] of members) {
+      for (const [client, member] of members) {
         if (!member.connected && (now - member.lastSeen) > SESSION_TTL_MS) {
-          broker.removeMember(roomId, sessionId);
+          broker.removeMember(roomId, client);
           totalRemoved++;
         }
       }
@@ -147,6 +178,7 @@ startSessionHeartbeatSync();
 
 // Promise-based dedup: concurrent calls for the same roomId share one promise.
 const roomDocPromises = new Map<string, Promise<string>>();
+const textDocPromises = new Map<string, Promise<string>>();
 
 // Session ID mapping: clientId (from query param) -> DB session ObjectId
 // This allows us to track which database session corresponds to each WebSocket connection
@@ -157,7 +189,7 @@ function ensureRoomDocument(roomId: string): Promise<string> {
     roomDocPromises.set(roomId, (async () => {
       const existing = await prisma.document.findFirst({ where: { name: roomId } });
       if (existing) return existing.id;
-      const docId = await journalService.createDocument(roomId, 'system');
+      const docId = await graphJournalService.createDocument(roomId, 'system');
       // console.log(`[journal] created document ${docId} for room "${roomId}"`);
       return docId;
     })());
@@ -165,18 +197,51 @@ function ensureRoomDocument(roomId: string): Promise<string> {
   return roomDocPromises.get(roomId)!;
 }
 
+function ensureTextDocument(docId: string): Promise<string> {
+  if (!textDocPromises.has(docId)) {
+    textDocPromises.set(docId, (async () => {
+      const existing = await prisma.textDocument.findFirst({ where: { name: docId } });
+      if (existing) return existing.id;
+      // Create new text document
+      const doc = await prisma.textDocument.create({
+        data: {
+          name: docId,
+          ownerId: 'system',
+          currentText: '',
+          version: 0,
+        },
+      });
+      // console.log(`[journal] created text document ${doc.id} for "${docId}"`);
+      return doc.id;
+    })());
+  }
+  return textDocPromises.get(docId)!;
+}
+
 const journalAdapter = {
   async processMessage(roomId: string, msg: any) {
     const docId = await ensureRoomDocument(roomId);
-    return journalService.processMessage(docId, msg);
+    return graphJournalService.processMessage(docId, msg);
   },
   async getStateForClient(roomId: string) {
     const docId = await ensureRoomDocument(roomId);
-    return journalService.getStateForClient(docId);
+    return graphJournalService.getStateForClient(docId);
+  },
+};
+
+const textJournalAdapter = {
+  async processMessage(docId: string, msg: any) {
+    const textDocId = await ensureTextDocument(docId);
+    return textJournalService.processMessage(textDocId, msg);
+  },
+  async getStateForClient(docId: string) {
+    const textDocId = await ensureTextDocument(docId);
+    return textJournalService.getStateForClient(textDocId);
   },
 };
 
 const rtcServer = new RTCServer(broker, journalAdapter as any);
+const textRtcServer = new RTCServer(broker, textJournalAdapter as any);
 
 function json(res: ServerResponse, data: unknown, status = 200) {
   res.writeHead(status, { 'Content-Type': 'application/json' });
@@ -207,13 +272,26 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
   try {
     // GET /api/stats
     if (path === '/api/stats') {
-      const [documents, journalBatches, operations, sessions] = await Promise.all([
+      const [documents, textDocuments, journalBatches, operations, sessions, textJournalBatches, textOperations, textSessions] = await Promise.all([
         db.document.count(),
+        db.textDocument.count(),
         db.journalBatch.count(),
         db.operation.count(),
         db.session.count(),
+        db.textJournalBatch.count(),
+        db.textOperation.count(),
+        db.textSession.count(),
       ]);
-      json(res, { documents, journalBatches, operations, sessions });
+      json(res, {
+        documents,
+        textDocuments,
+        journalBatches,
+        operations,
+        sessions,
+        textJournalBatches,
+        textOperations,
+        textSessions,
+      });
       return;
     }
 
@@ -394,7 +472,43 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
       return;
     }
 
-    // GET /api/documents
+    // GET /api/graph — list all graph documents
+    if (path === '/api/graph') {
+      const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '100', 10), 1000);
+      const offset = parseInt(url.searchParams.get('offset') ?? '0', 10);
+
+      const [docs, total] = await Promise.all([
+        db.document.findMany({
+          orderBy: { updatedAt: 'desc' },
+          select: { id: true, name: true, ownerId: true, version: true, createdAt: true, updatedAt: true },
+          take: limit,
+          skip: offset,
+        }),
+        db.document.count(),
+      ]);
+      json(res, { documents: docs, total });
+      return;
+    }
+
+    // GET /api/text — list all text documents
+    if (path === '/api/text') {
+      const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '100', 10), 1000);
+      const offset = parseInt(url.searchParams.get('offset') ?? '0', 10);
+
+      const [docs, total] = await Promise.all([
+        db.textDocument.findMany({
+          orderBy: { updatedAt: 'desc' },
+          select: { id: true, name: true, ownerId: true, version: true, createdAt: true, updatedAt: true },
+          take: limit,
+          skip: offset,
+        }),
+        db.textDocument.count(),
+      ]);
+      json(res, { documents: docs, total });
+      return;
+    }
+
+    // GET /api/documents — legacy redirect to /api/graph
     if (path === '/api/documents') {
       const docs = await db.document.findMany({
         orderBy: { updatedAt: 'desc' },
@@ -404,6 +518,331 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
       return;
     }
 
+    // ── Graph Document Endpoints ──
+
+    // GET /api/graph/:id[/sub]
+    const graphMatch = path.match(/^\/api\/graph\/([^/]+)(\/.*)?$/);
+    if (graphMatch) {
+      const docId = graphMatch[1];
+      const sub = graphMatch[2] ?? '';
+
+      // GET /api/graph/:id
+      if ((sub === '' || sub === '/') && req.method === 'GET') {
+        const doc = await db.document.findUnique({ where: { id: docId } });
+        if (!doc) { json(res, { error: 'Not found' }, 404); return; }
+        json(res, doc);
+        return;
+      }
+
+      // GET /api/graph/:id/journal
+      if (sub === '/journal' && req.method === 'GET') {
+        const order = url.searchParams.get('order') === 'asc' ? 'asc' : 'desc';
+        const limit = Math.min(Math.max(1, Number(url.searchParams.get('limit')) || 100), 1000);
+        const offset = Math.max(0, Number(url.searchParams.get('offset')) || 0);
+
+        const [batches, total] = await Promise.all([
+          db.journalBatch.findMany({
+            where: { documentId: docId },
+            orderBy: { persistedAt: order },
+            take: limit,
+            skip: offset,
+          }),
+          db.journalBatch.count({ where: { documentId: docId } }),
+        ]);
+        json(res, { batches, total, limit, offset, order });
+        return;
+      }
+
+      // GET /api/graph/:id/operations
+      if (sub === '/operations' && req.method === 'GET') {
+        const order = url.searchParams.get('order') === 'asc' ? 'asc' : 'desc';
+        const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '100', 10), 1000);
+        const offset = parseInt(url.searchParams.get('offset') ?? '0', 10);
+
+        const batches = await db.journalBatch.findMany({
+          where: { documentId: docId },
+          orderBy: { lamportTime: order },
+        });
+
+        const allOps: any[] = [];
+        for (const batch of batches) {
+          const ops = Array.isArray(batch.operations) ? batch.operations : [];
+          for (const op of ops) {
+            allOps.push({
+              ...(op as object),
+              client: batch.client,
+              batchId: batch.batchId,
+              lamportTime: batch.lamportTime,
+              persistedAt: batch.persistedAt,
+            });
+          }
+        }
+
+        if (order === 'desc') {
+          allOps.sort((a, b) => (b.lamportTime ?? 0) - (a.lamportTime ?? 0));
+        } else {
+          allOps.sort((a, b) => (a.lamportTime ?? 0) - (b.lamportTime ?? 0));
+        }
+
+        const total = allOps.length;
+        const paginatedOps = allOps.slice(offset, offset + limit);
+
+        json(res, { operations: paginatedOps, total, limit, offset, order });
+        return;
+      }
+
+      // GET /api/graph/:id/sessions
+      if (sub === '/sessions' && req.method === 'GET') {
+        const sessions = await db.session.findMany({
+          where: { documentId: docId },
+          orderBy: { lastSeenAt: 'desc' },
+        });
+        json(res, { sessions });
+        return;
+      }
+
+      // POST /api/graph/:id/compact
+      if (sub === '/compact' && req.method === 'POST') {
+        try {
+          const beforeBatches = await db.journalBatch.findMany({ where: { documentId: docId } });
+          const beforeOpsCount = beforeBatches.reduce((sum, b) => {
+            const ops = Array.isArray(b.operations) ? b.operations : [];
+            return sum + ops.length;
+          }, 0);
+
+          await graphJournalService.compact(docId);
+
+          const afterBatches = await db.journalBatch.findMany({ where: { documentId: docId } });
+          const afterOpsCount = afterBatches.reduce((sum, b) => {
+            const ops = Array.isArray(b.operations) ? b.operations : [];
+            return sum + ops.length;
+          }, 0);
+
+          json(res, {
+            message: 'Compaction triggered',
+            before: { journal: beforeBatches.length, snapshot: beforeOpsCount },
+            after: { journal: afterBatches.length, snapshot: afterOpsCount },
+          });
+        } catch (e: any) {
+          json(res, { error: e.message }, 500);
+        }
+        return;
+      }
+
+      // POST /api/graph/:id/coalesce
+      if (sub === '/coalesce' && req.method === 'POST') {
+        try {
+          let config: any = {};
+          if (req.headers['content-length'] && parseInt(req.headers['content-length']) > 0) {
+            const body = await new Promise<string>((resolve) => {
+              let data = '';
+              req.on('data', chunk => data += chunk);
+              req.on('end', () => resolve(data));
+            });
+            if (body) {
+              try {
+                config = JSON.parse(body);
+              } catch {
+                // Ignore parse errors, use defaults
+              }
+            }
+          }
+
+          const result = await coalescingService.coalesce(docId, config);
+          json(res, result);
+        } catch (e: any) {
+          json(res, { error: e.message }, 500);
+        }
+        return;
+      }
+
+      // DELETE /api/graph/:id
+      if ((sub === '' || sub === '/') && req.method === 'DELETE') {
+        try {
+          const sessionsDeleted = await db.session.deleteMany({ where: { documentId: docId } });
+          const batchesDeleted = await db.journalBatch.deleteMany({ where: { documentId: docId } });
+          const opsDeleted = await db.operation.deleteMany({ where: { documentId: docId } });
+          const doc = await db.document.delete({ where: { id: docId } });
+
+          const roomId = doc.name;
+          rtcServer.clearRoom(roomId);
+          await broker.clearRoom(roomId);
+          roomDocPromises.delete(roomId);
+
+          json(res, {
+            message: 'Document deleted',
+            id: docId,
+            deleted: {
+              sessions: sessionsDeleted.count,
+              journalBatches: batchesDeleted.count,
+              operations: opsDeleted.count,
+            },
+          });
+        } catch (e: any) {
+          json(res, { error: e.message }, 404);
+        }
+        return;
+      }
+    }
+
+    // ── Text Document Endpoints ──
+
+    // GET /api/text/:id[/sub]
+    const textDocMatch = path.match(/^\/api\/text\/([^/]+)(\/.*)?$/);
+    if (textDocMatch) {
+      const docId = textDocMatch[1];
+      const sub = textDocMatch[2] ?? '';
+
+      // GET /api/text/:id
+      if ((sub === '' || sub === '/') && req.method === 'GET') {
+        const doc = await db.textDocument.findUnique({ where: { id: docId } });
+        if (!doc) { json(res, { error: 'Not found' }, 404); return; }
+        json(res, {
+          id: doc.id,
+          name: doc.name,
+          currentText: doc.currentText,
+          version: doc.version,
+        });
+        return;
+      }
+
+      // GET /api/text/:id/journal
+      if (sub === '/journal' && req.method === 'GET') {
+        const order = url.searchParams.get('order') === 'asc' ? 'asc' : 'desc';
+        const limit = Math.min(Math.max(1, Number(url.searchParams.get('limit')) || 100), 1000);
+        const offset = Math.max(0, Number(url.searchParams.get('offset')) || 0);
+
+        const [batches, total] = await Promise.all([
+          db.textJournalBatch.findMany({
+            where: { textDocumentId: docId },
+            orderBy: { persistedAt: order },
+            take: limit,
+            skip: offset,
+          }),
+          db.textJournalBatch.count({ where: { textDocumentId: docId } }),
+        ]);
+        json(res, { batches, total, limit, offset, order });
+        return;
+      }
+
+      // GET /api/text/:id/operations
+      if (sub === '/operations' && req.method === 'GET') {
+        const order = url.searchParams.get('order') === 'asc' ? 'asc' : 'desc';
+        const limit = Math.min(parseInt(url.searchParams.get('limit') ?? '100', 10), 1000);
+        const offset = parseInt(url.searchParams.get('offset') ?? '0', 10);
+
+        const batches = await db.textJournalBatch.findMany({
+          where: { textDocumentId: docId },
+          orderBy: { lamportTime: order },
+        });
+
+        const allOps: any[] = [];
+        for (const batch of batches) {
+          const ops = Array.isArray(batch.operations) ? batch.operations : [];
+          for (const op of ops) {
+            allOps.push({
+              ...(op as object),
+              client: batch.client,
+              batchId: batch.batchId,
+              lamportTime: batch.lamportTime,
+              persistedAt: batch.persistedAt,
+            });
+          }
+        }
+
+        if (order === 'desc') {
+          allOps.sort((a, b) => (b.lamportTime ?? 0) - (a.lamportTime ?? 0));
+        } else {
+          allOps.sort((a, b) => (a.lamportTime ?? 0) - (b.lamportTime ?? 0));
+        }
+
+        const total = allOps.length;
+        const paginatedOps = allOps.slice(offset, offset + limit);
+
+        json(res, { operations: paginatedOps, total, limit, offset, order });
+        return;
+      }
+
+      // GET /api/text/:id/sessions
+      if (sub === '/sessions' && req.method === 'GET') {
+        const sessions = await db.textSession.findMany({
+          where: { textDocumentId: docId },
+          orderBy: { lastSeenAt: 'desc' },
+        });
+        json(res, { sessions });
+        return;
+      }
+
+      // POST /api/text/:id/compact
+      if (sub === '/compact' && req.method === 'POST') {
+        try {
+          const beforeBatches = await db.textJournalBatch.findMany({ where: { textDocumentId: docId } });
+          const beforeOpsCount = beforeBatches.reduce((sum, b) => {
+            const ops = Array.isArray(b.operations) ? b.operations : [];
+            return sum + ops.length;
+          }, 0);
+
+          await textJournalService.compact(docId);
+
+          const afterBatches = await db.textJournalBatch.findMany({ where: { textDocumentId: docId } });
+          const afterOpsCount = afterBatches.reduce((sum, b) => {
+            const ops = Array.isArray(b.operations) ? b.operations : [];
+            return sum + ops.length;
+          }, 0);
+
+          json(res, {
+            message: 'Compaction triggered',
+            before: { journal: beforeBatches.length, operations: beforeOpsCount },
+            after: { journal: afterBatches.length, operations: afterOpsCount },
+          });
+        } catch (e: any) {
+          json(res, { error: e.message }, 500);
+        }
+        return;
+      }
+
+      // POST /api/text/:id/coalesce
+      if (sub === '/coalesce' && req.method === 'POST') {
+        try {
+          // TODO: Implement text coalescing
+          json(res, { error: 'Text coalescing not yet implemented' }, 501);
+        } catch (e: any) {
+          json(res, { error: e.message }, 500);
+        }
+        return;
+      }
+
+      // DELETE /api/text/:id
+      if ((sub === '' || sub === '/') && req.method === 'DELETE') {
+        try {
+          const sessionsDeleted = await db.textSession.deleteMany({ where: { textDocumentId: docId } });
+          const batchesDeleted = await db.textJournalBatch.deleteMany({ where: { textDocumentId: docId } });
+          const opsDeleted = await db.textOperation.deleteMany({ where: { textDocumentId: docId } });
+          const doc = await db.textDocument.delete({ where: { id: docId } });
+
+          const textDocName = doc.name;
+          textRtcServer.clearRoom(textDocName);
+          await broker.clearRoom(textDocName);
+          textDocPromises.delete(textDocName);
+
+          json(res, {
+            message: 'Text document deleted',
+            id: docId,
+            deleted: {
+              sessions: sessionsDeleted.count,
+              journalBatches: batchesDeleted.count,
+              operations: opsDeleted.count,
+            },
+          });
+        } catch (e: any) {
+          json(res, { error: e.message }, 404);
+        }
+        return;
+      }
+    }
+
+    // ── Legacy Document Endpoints (redirect to /api/graph/) ──
+
     // GET /api/documents/:id[/sub]
     const docMatch = path.match(/^\/api\/documents\/([^/]+)(\/.*)?$/);
     if (docMatch && req.method === 'GET') {
@@ -455,7 +894,7 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
           for (const op of ops) {
             allOps.push({
               ...(op as object),
-              sessionId: batch.sessionId,
+              client: batch.client,
               batchId: batch.batchId,
               lamportTime: batch.lamportTime,
               persistedAt: batch.persistedAt,
@@ -478,7 +917,7 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
       }
 
       if (sub === '/sessions') {
-        // Sessions are derived from JournalBatch sessionIds since Session collection isn't used
+        // Sessions are derived from JournalBatch clients since Session collection isn't used
         const batches = await db.journalBatch.findMany({
           where: { documentId: docId },
           orderBy: { persistedAt: 'desc' },
@@ -486,7 +925,7 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
 
         // Aggregate session info from batches
         const sessionMap = new Map<string, {
-          sessionId: string;
+          client: string;
           batchCount: number;
           operationCount: number;
           firstSeen: Date;
@@ -495,9 +934,9 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
         }>();
 
         for (const batch of batches) {
-          const sid = batch.sessionId;
+          const cid = batch.client;
           const ops = Array.isArray(batch.operations) ? batch.operations : [];
-          const existing = sessionMap.get(sid);
+          const existing = sessionMap.get(cid);
           if (existing) {
             existing.batchCount++;
             existing.operationCount += ops.length;
@@ -505,8 +944,8 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
             if (batch.persistedAt > existing.lastSeen) existing.lastSeen = batch.persistedAt;
             existing.lastLamportTime = Math.max(existing.lastLamportTime, batch.lamportTime ?? 0);
           } else {
-            sessionMap.set(sid, {
-              sessionId: sid,
+            sessionMap.set(cid, {
+              client: cid,
               batchCount: 1,
               operationCount: ops.length,
               firstSeen: batch.persistedAt,
@@ -546,7 +985,7 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
       if (docPromise) {
         try {
           const docId = await docPromise;
-          await journalService.clearDocument(docId);
+          await graphJournalService.clearDocument(docId);
           // console.log(`[api] cleared document ${docId} for room "${targetRoomId}"`);
         } catch (e: any) {
           console.warn(`[api] clear doc error:`, e);
@@ -575,7 +1014,7 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
         console.log(`[compact] Starting compaction for doc ${docId}: ${beforeBatches.length} batches, ${beforeOpsCount} ops`);
 
         // Run compaction (no watermark = compact everything)
-        await journalService.compact(docId);
+        await graphJournalService.compact(docId);
 
         // Get after stats
         const afterBatches = await db.journalBatch.findMany({ where: { documentId: docId } });
@@ -675,9 +1114,9 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
 
       const members = await broker.getMembers(roomId);
       let removed = 0;
-      for (const [sessionId, member] of members) {
+      for (const [client, member] of members) {
         if (!member.connected && (now - member.lastSeen) > maxAge) {
-          broker.removeMember(roomId, sessionId);
+          broker.removeMember(roomId, client);
           removed++;
         }
       }
@@ -691,26 +1130,26 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
     if (leaveMatch && req.method === 'POST') {
       const roomId = leaveMatch[1];
 
-      // Parse body for sessionId
+      // Parse body for client
       let body = '';
       for await (const chunk of req) {
         body += chunk;
       }
 
-      let sessionId: string | undefined;
+      let client: string | undefined;
       try {
         const data = JSON.parse(body);
-        sessionId = data.sessionId;
+        client = data.client;
       } catch {
         // Ignore parse errors - beacon may send empty body
       }
 
-      if (sessionId) {
+      if (client) {
         // Mark as disconnected and remove immediately
         const members = await broker.getMembers(roomId);
-        if (members.has(sessionId)) {
-          broker.removeMember(roomId, sessionId);
-          json(res, { ok: true, removed: true, sessionId });
+        if (members.has(client)) {
+          broker.removeMember(roomId, client);
+          json(res, { ok: true, removed: true, client });
           return;
         }
       }
@@ -742,7 +1181,7 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
 
       // Convert batches to CRDTMessage format for RLE encoding
       const allMessages: any[] = batches.map(batch => ({
-        sessionId: batch.sessionId,
+        client: batch.client,
         lamportTime: batch.lamportTime ?? 0,
         timestamp: new Date(batch.persistedAt).getTime(),
         ops: Array.isArray(batch.operations) ? batch.operations : [],
@@ -757,7 +1196,7 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
       const compressionRatio = rawSize > 0 ? (rawSize - gzipSize) / rawSize : 0;
 
       // Calculate batching metrics
-      const uniqueSessions = new Set(allMessages.map(m => m.sessionId)).size;
+      const uniqueSessions = new Set(allMessages.map(m => m.client)).size;
       const totalOps = allMessages.reduce((sum, m) => sum + (m.ops?.length ?? 1), 0);
       const avgOpsPerBatch = batches.length > 0 ? totalOps / batches.length : 0;
       const batchingEfficiency = allMessages.length > 0 ? batches.length / allMessages.length : 0;
@@ -799,8 +1238,8 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
       // Calculate operation type distribution from journal ops
       const typeDistribution: Record<string, number> = {};
       for (const op of flatOps) {
-        const otype = op.otype ?? op.type ?? 'unknown';
-        typeDistribution[otype] = (typeDistribution[otype] ?? 0) + 1;
+        const ot = op.ot ?? op.type ?? 'unknown';
+        typeDistribution[ot] = (typeDistribution[ot] ?? 0) + 1;
       }
 
       // Calculate lamport range from batches
@@ -810,14 +1249,14 @@ async function handleApi(req: IncomingMessage, res: ServerResponse): Promise<voi
         : [0, 0];
 
       // Calculate vector clock complexity from batches
-      const uniqueSessionsInClocks = new Set<string>();
+      const uniqueClientsInClocks = new Set<string>();
       for (const batch of batches) {
         const clock = batch.vectorClock as Record<string, number> | null;
         if (clock && typeof clock === 'object') {
-          Object.keys(clock).forEach(sessionId => uniqueSessionsInClocks.add(sessionId));
+          Object.keys(clock).forEach(client => uniqueClientsInClocks.add(client));
         }
       }
-      const vectorClockComplexity = uniqueSessionsInClocks.size;
+      const vectorClockComplexity = uniqueClientsInClocks.size;
 
       json(res, {
         storage: {
@@ -881,67 +1320,132 @@ const wss = new WebSocketServer({ server, path: undefined });
 wss.on('connection', (ws, req) => {
   const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
 
-  // Expect /ws/{roomId}
-  const match = url.pathname.match(/^\/ws\/([^/]+)$/);
-  if (!match) {
-    ws.close(4000, 'Invalid path — expected /ws/{roomId}');
+  // Match either /ws/graph/{roomId} or /ws/text/{docId}
+  const graphMatch = url.pathname.match(/^\/ws\/graph\/([^/]+)$/);
+  const textMatch = url.pathname.match(/^\/ws\/text\/([^/]+)$/);
+
+  if (!graphMatch && !textMatch) {
+    ws.close(4000, 'Invalid path — expected /ws/graph/{roomId} or /ws/text/{docId}');
     return;
   }
 
-  const roomId = decodeURIComponent(match[1]);
-  const sessionId = url.searchParams.get('sessionId');
-  if (!sessionId) {
-    ws.close(4001, 'Missing sessionId query parameter');
+  const client = url.searchParams.get('client');
+  if (!client) {
+    ws.close(4001, 'Missing client query parameter');
     return;
   }
 
-  // Wire up the connection immediately so messages aren't lost.
-  // The journalAdapter handles room creation lazily inside processMessage.
-  rtcServer.handleConnection(ws, roomId, sessionId);
+  // Handle graph document connection
+  if (graphMatch) {
+    const roomId = decodeURIComponent(graphMatch[1]);
 
-  // Create session record in database after ensuring document exists
-  ensureRoomDocument(roomId)
-    .then(async (docId) => {
-      // Create session in database
-      try {
-        const dbSession = await sessionRepo.create({
-          documentId: docId,
-          userId: url.searchParams.get('userId') ?? 'anonymous',
-          clientId: sessionId,
-        });
-        sessionIdMap.set(sessionId, dbSession.id);
-        // console.log(`[session] created session ${dbSession.id} for client ${sessionId} in doc ${docId}`);
-      } catch (err) {
-        console.error(`[session] failed to create session for ${sessionId}:`, err);
-      }
-
-      // Send stored state
-      return rtcServer.handleStateTransfer(ws, roomId);
-    })
-    .catch((err) => console.error(`[state-transfer] room="${roomId}":`, err));
-
-  // Handle disconnect — mark session as disconnected
-  ws.on('close', () => {
-    const dbSessionId = sessionIdMap.get(sessionId);
-    if (dbSessionId) {
-      sessionRepo.disconnect(dbSessionId)
-        .then(() => {
-          // console.log(`[session] disconnected session ${dbSessionId} for client ${sessionId}`);
-          sessionIdMap.delete(sessionId);
+    // Wire up the connection immediately so messages aren't lost.
+    rtcServer.handleConnection(ws, roomId, client);
+
+    // Create session record in database after ensuring document exists
+    ensureRoomDocument(roomId)
+      .then(async (docId) => {
+        try {
+          const dbSession = await sessionRepo.create({
+            documentId: docId,
+            userId: url.searchParams.get('userId') ?? 'anonymous',
+            clientId: client,
+          });
+          sessionIdMap.set(client, dbSession.id);
+          // console.log(`[session] created graph session ${dbSession.id} for client ${client} in doc ${docId}`);
+        } catch (err) {
+          console.error(`[session] failed to create graph session for ${client}:`, err);
+        }
+
+        // Send stored state
+        return rtcServer.handleStateTransfer(ws, roomId);
+      })
+      .catch((err) => console.error(`[state-transfer] room="${roomId}":`, err));
+
+    // Handle disconnect — mark session as disconnected
+    ws.on('close', () => {
+      const dbSessionId = sessionIdMap.get(client);
+      if (dbSessionId) {
+        sessionRepo.disconnect(dbSessionId)
+          .then(() => {
+            // console.log(`[session] disconnected graph session ${dbSessionId}`);
+            sessionIdMap.delete(client);
+          })
+          .catch((err) => console.error(`[session] failed to disconnect session ${dbSessionId}:`, err));
+      }
+    });
+  }
+
+  // Handle text document connection
+  if (textMatch) {
+    const docId = decodeURIComponent(textMatch[1]);
+
+    // Wire up the connection immediately so messages aren't lost.
+    textRtcServer.handleConnection(ws, docId, client);
+
+    // Create session record in database after ensuring text document exists
+    ensureTextDocument(docId)
+      .then(async (textDocId) => {
+        try {
+          const dbSession = await prisma.textSession.create({
+            data: {
+              textDocumentId: textDocId,
+              userId: url.searchParams.get('userId') ?? 'anonymous',
+              clientId: client,
+              clockValue: 0,
+            },
+          });
+          sessionIdMap.set(client, dbSession.id);
+          // console.log(`[session] created text session ${dbSession.id} for client ${client} in doc ${textDocId}`);
+        } catch (err) {
+          console.error(`[session] failed to create text session for ${client}:`, err);
+        }
+
+        // Send stored state
+        return textRtcServer.handleStateTransfer(ws, docId);
+      })
+      .catch((err) => console.error(`[state-transfer] text-doc="${docId}":`, err));
+
+    // Handle disconnect — mark session as disconnected
+    ws.on('close', () => {
+      const dbSessionId = sessionIdMap.get(client);
+      if (dbSessionId) {
+        prisma.textSession.update({
+          where: { id: dbSessionId },
+          data: {
+            connected: false,
+            disconnectedAt: new Date(),
+          },
         })
-        .catch((err) => console.error(`[session] failed to disconnect session ${dbSessionId}:`, err));
-    }
-  });
+          .then(() => {
+            // console.log(`[session] disconnected text session ${dbSessionId}`);
+            sessionIdMap.delete(client);
+          })
+          .catch((err) => console.error(`[session] failed to disconnect text session ${dbSessionId}:`, err));
+      }
+    });
+  }
 });
 
 server.listen(PORT, () => {
-  // console.log(`vuer-rtc server listening on http://localhost:${PORT}`);
+  const cyan = '\x1b[36m';
+  const yellow = '\x1b[33m';
+  const green = '\x1b[32m';
+  const bold = '\x1b[1m';
+  const reset = '\x1b[0m';
+
+  console.log(`\n${green}${bold}✓${reset} ${green}vuer-rtc server ready${reset}`);
+  console.log(`  ${bold}HTTP:${reset}      ${cyan}http://localhost:${yellow}${PORT}${reset}`);
+  console.log(`  ${bold}WebSocket:${reset} ${cyan}ws://localhost:${yellow}${PORT}${cyan}/ws/graph/{roomId}${reset}`);
+  console.log(`  ${bold}           ${cyan}ws://localhost:${yellow}${PORT}${cyan}/ws/text/{docId}${reset}`);
+  console.log(`  ${bold}REST API:${reset}  ${cyan}http://localhost:${yellow}${PORT}${cyan}/api${reset}\n`);
 });
 
 // ── Graceful shutdown ──
 
 function shutdown() {
-  journalService.stopCompactionLoop();
+  graphJournalService.stopCompactionLoop();
+  textJournalService.stopCompactionLoop();
   stopSessionHeartbeatSync();
   stopSessionCleanupLoop();
   server.close(() => {