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

package/dist/serve.js

@@ -2,37 +2,56 @@
  * 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 } from 'http';
 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';
 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) => {
+graphJournalService.setMemberClockProvider(async (docId) => {
     // Reverse-lookup: docId -> roomId (room name is used as document name)
     const doc = await prisma.document.findUnique({ where: { id: docId } });
     if (!doc)
@@ -42,7 +61,19 @@ journalService.setMemberClockProvider(async (docId) => {
         .filter((m) => m.connected)
         .map((m) => m.vectorClock);
 });
-journalService.startCompactionLoop();
+// Wire the broker's member clocks into the text journal service
+textJournalService.setMemberClockProvider(async (docId) => {
+    // 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.
 const SESSION_TTL_MS = 2 * 60 * 1000; // 2 minutes
@@ -57,9 +88,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++;
                 }
             }
@@ -129,6 +160,7 @@ startSessionHeartbeatSync();
 // This adapter auto-creates a Document per room and maps between them.
 // Promise-based dedup: concurrent calls for the same roomId share one promise.
 const roomDocPromises = new Map();
+const textDocPromises = new Map();
 // Session ID mapping: clientId (from query param) -> DB session ObjectId
 // This allows us to track which database session corresponds to each WebSocket connection
 const sessionIdMap = new Map();
@@ -138,24 +170,56 @@ function ensureRoomDocument(roomId) {
             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;
         })());
     }
     return roomDocPromises.get(roomId);
 }
+function ensureTextDocument(docId) {
+    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, msg) {
         const docId = await ensureRoomDocument(roomId);
-        return journalService.processMessage(docId, msg);
+        return graphJournalService.processMessage(docId, msg);
     },
     async getStateForClient(roomId) {
         const docId = await ensureRoomDocument(roomId);
-        return journalService.getStateForClient(docId);
+        return graphJournalService.getStateForClient(docId);
+    },
+};
+const textJournalAdapter = {
+    async processMessage(docId, msg) {
+        const textDocId = await ensureTextDocument(docId);
+        return textJournalService.processMessage(textDocId, msg);
+    },
+    async getStateForClient(docId) {
+        const textDocId = await ensureTextDocument(docId);
+        return textJournalService.getStateForClient(textDocId);
     },
 };
 const rtcServer = new RTCServer(broker, journalAdapter);
+const textRtcServer = new RTCServer(broker, textJournalAdapter);
 function json(res, data, status = 200) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(data));
@@ -179,13 +243,26 @@ async function handleApi(req, res) {
     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;
         }
         // GET /api/stats/sizes — detailed size breakdown
@@ -348,7 +425,39 @@ async function handleApi(req, res) {
             });
             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' },
@@ -357,6 +466,304 @@ async function handleApi(req, res) {
             json(res, docs);
             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 = [];
+                for (const batch of batches) {
+                    const ops = Array.isArray(batch.operations) ? batch.operations : [];
+                    for (const op of ops) {
+                        allOps.push({
+                            ...op,
+                            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) {
+                    json(res, { error: e.message }, 500);
+                }
+                return;
+            }
+            // POST /api/graph/:id/coalesce
+            if (sub === '/coalesce' && req.method === 'POST') {
+                try {
+                    let config = {};
+                    if (req.headers['content-length'] && parseInt(req.headers['content-length']) > 0) {
+                        const body = await new Promise((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) {
+                    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) {
+                    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 = [];
+                for (const batch of batches) {
+                    const ops = Array.isArray(batch.operations) ? batch.operations : [];
+                    for (const op of ops) {
+                        allOps.push({
+                            ...op,
+                            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) {
+                    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) {
+                    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) {
+                    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') {
@@ -405,7 +812,7 @@ async function handleApi(req, res) {
                     for (const op of ops) {
                         allOps.push({
                             ...op,
-                            sessionId: batch.sessionId,
+                            client: batch.client,
                             batchId: batch.batchId,
                             lamportTime: batch.lamportTime,
                             persistedAt: batch.persistedAt,
@@ -425,7 +832,7 @@ async function handleApi(req, res) {
                 return;
             }
             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' },
@@ -433,9 +840,9 @@ async function handleApi(req, res) {
                 // Aggregate session info from batches
                 const sessionMap = new Map();
                 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;
@@ -446,8 +853,8 @@ async function handleApi(req, res) {
                         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,
@@ -481,7 +888,7 @@ async function handleApi(req, res) {
             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) {
@@ -507,7 +914,7 @@ async function handleApi(req, res) {
                 }, 0);
                 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 } });
                 const afterOpsCount = afterBatches.reduce((sum, b) => {
@@ -599,9 +1006,9 @@ async function handleApi(req, res) {
             const now = Date.now();
             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++;
                 }
             }
@@ -612,25 +1019,25 @@ async function handleApi(req, res) {
         const leaveMatch = path.match(/^\/api\/rooms\/([^/]+)\/leave$/);
         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;
+            let client;
             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;
                 }
             }
@@ -658,7 +1065,7 @@ async function handleApi(req, res) {
             const rawSize = JSON.stringify(batches.map(b => b.operations)).length;
             // Convert batches to CRDTMessage format for RLE encoding
             const allMessages = 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 : [],
@@ -670,7 +1077,7 @@ async function handleApi(req, res) {
             const gzipSize = gzipStats.compressedSize;
             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;
@@ -705,8 +1112,8 @@ async function handleApi(req, res) {
             // Calculate operation type distribution from journal ops
             const typeDistribution = {};
             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
             const lamportTimes = batches.map(b => b.lamportTime ?? 0);
@@ -714,14 +1121,14 @@ async function handleApi(req, res) {
                 ? [Math.min(...lamportTimes), Math.max(...lamportTimes)]
                 : [0, 0];
             // Calculate vector clock complexity from batches
-            const uniqueSessionsInClocks = new Set();
+            const uniqueClientsInClocks = new Set();
             for (const batch of batches) {
                 const clock = batch.vectorClock;
                 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: {
                     rawSize,
@@ -776,60 +1183,118 @@ const server = createServer((req, res) => {
 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);
-    // 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);
-            })
-                .catch((err) => console.error(`[session] failed to disconnect session ${dbSessionId}:`, err));
-        }
-    });
+    // Handle graph document connection
+    if (graphMatch) {
+        const roomId = decodeURIComponent(graphMatch[1]);
+        // 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(),
+                    },
+                })
+                    .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(() => {