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

package/prisma/schema.prisma

@@ -10,7 +10,7 @@ datasource db {
   url      = env("DATABASE_URL")
 }
 
-// Document represents a collaborative 3D scene
+// Document represents a collaborative 3D scene graph
 model Document {
   id           String   @id @default(auto()) @map("_id") @db.ObjectId
   name         String
@@ -19,7 +19,7 @@ model Document {
   updatedAt    DateTime @updatedAt
 
   // Current state snapshot (for fast loading without replaying all operations)
-  currentState Json     // Serialized SceneState
+  currentState Json     // Serialized SceneGraph
   version      Int      @default(0) // Monotonically increasing version number
 
   // Relations
@@ -31,6 +31,27 @@ model Document {
   @@index([updatedAt])
 }
 
+// TextDocument represents a collaborative text document (standalone CRDT)
+model TextDocument {
+  id           String   @id @default(auto()) @map("_id") @db.ObjectId
+  name         String
+  ownerId      String
+  createdAt    DateTime @default(now())
+  updatedAt    DateTime @updatedAt
+
+  // Current text content (plain string from TextRope.toJSON())
+  currentText  Json     // Plain string or serialized TextRope
+  version      Int      @default(0) // Monotonically increasing version number
+
+  // Relations
+  textOperations     TextOperation[]
+  textSessions       TextSession[]
+  textJournalBatches TextJournalBatch[]
+
+  @@index([ownerId])
+  @@index([updatedAt])
+}
+
 // Operation represents a single edit operation (event sourcing)
 model Operation {
   id          String   @id @default(auto()) @map("_id") @db.ObjectId
@@ -68,7 +89,7 @@ model Operation {
 model JournalBatch {
   id          String   @id @default(auto()) @map("_id") @db.ObjectId
   documentId  String   @db.ObjectId
-  sessionId   String   // Session that created these operations
+  client      String   // Client that created these operations
 
   // Batch identification
   batchId     String   // Client-generated batch UUID
@@ -77,7 +98,7 @@ model JournalBatch {
   operations  Json[]   // Array of serialized operations
 
   // CRDT ordering metadata (optional for backward compat with existing rows)
-  vectorClock Json?            // Map of sessionId -> counter (causal ordering)
+  vectorClock Json?            // Map of client -> counter (causal ordering)
   lamportTime Int?  @default(0) // Lamport timestamp for deterministic tie-breaking
   deletedAt   DateTime?        // Soft-delete timestamp (set by meta.undo)
 
@@ -92,10 +113,10 @@ model JournalBatch {
   @@unique([documentId, batchId])
   @@index([documentId, persistedAt])
   @@index([documentId, lamportTime])
-  @@index([sessionId])
+  @@index([client])
 }
 
-// Session represents a client connection
+// Session represents a client connection to a graph document
 model Session {
   id             String    @id @default(auto()) @map("_id") @db.ObjectId
   documentId     String    @db.ObjectId
@@ -125,3 +146,100 @@ model Session {
   @@index([clientId])
   @@index([documentId, connected])
 }
+
+// ====================================
+// Text Document Models
+// ====================================
+
+// TextOperation represents a single text edit operation
+model TextOperation {
+  id             String   @id @default(auto()) @map("_id") @db.ObjectId
+  textDocumentId String   @db.ObjectId
+  textSessionId  String   @db.ObjectId
+
+  // Operation identification
+  opId           String   // Client-generated UUID for idempotency
+  type           String   // "text.insert" | "text.delete" | "text.replace"
+
+  // Operation payload
+  data           Json     // Type-specific operation data
+
+  // CRDT ordering metadata
+  vectorClock    Json     // Map of sessionId -> counter (causal ordering)
+  lamportTime    Int      // Lamport timestamp for deterministic tie-breaking
+
+  // Timestamps
+  createdAt      DateTime @default(now())
+  appliedAt      DateTime @default(now())
+
+  // Relations
+  textDocument   TextDocument @relation(fields: [textDocumentId], references: [id], onDelete: Cascade)
+  textSession    TextSession  @relation(fields: [textSessionId], references: [id], onDelete: Cascade)
+
+  @@unique([textDocumentId, opId])
+  @@index([textDocumentId, lamportTime])
+  @@index([textSessionId])
+  @@index([textDocumentId, createdAt])
+}
+
+// TextJournalBatch represents a batched write-ahead log entry for text operations
+model TextJournalBatch {
+  id             String   @id @default(auto()) @map("_id") @db.ObjectId
+  textDocumentId String   @db.ObjectId
+  client         String   // Client that created these operations
+
+  // Batch identification
+  batchId        String   // Client-generated batch UUID
+
+  // Batched operations (array of operation data)
+  operations     Json[]   // Array of serialized operations
+
+  // CRDT ordering metadata
+  vectorClock    Json?    // Map of client -> counter (causal ordering)
+  lamportTime    Int?     @default(0) // Lamport timestamp for deterministic tie-breaking
+  deletedAt      DateTime? // Soft-delete timestamp (set by meta.undo)
+
+  // Timing metadata
+  startTime      DateTime // Timestamp of first operation in batch
+  endTime        DateTime // Timestamp of last operation in batch
+  persistedAt    DateTime @default(now()) // When this batch was saved to DB
+
+  // Relations
+  textDocument   TextDocument @relation(fields: [textDocumentId], references: [id], onDelete: Cascade)
+
+  @@unique([textDocumentId, batchId])
+  @@index([textDocumentId, persistedAt])
+  @@index([textDocumentId, lamportTime])
+  @@index([client])
+}
+
+// TextSession represents a client connection to a text document
+model TextSession {
+  id             String    @id @default(auto()) @map("_id") @db.ObjectId
+  textDocumentId String    @db.ObjectId
+
+  // User and client identification
+  userId         String
+  clientId       String    // Unique client identifier (for reconnection)
+
+  // Vector clock state for this session
+  clockValue     Int       @default(0) // This session's clock counter
+
+  // Connection state
+  connected      Boolean   @default(true)
+  connectedAt    DateTime  @default(now())
+  disconnectedAt DateTime?
+  lastSeenAt     DateTime  @default(now())
+
+  // Presence data (cursor position, selection, etc.)
+  presence       Json?     // PresenceData structure
+
+  // Relations
+  textDocument   TextDocument   @relation(fields: [textDocumentId], references: [id], onDelete: Cascade)
+  textOperations TextOperation[]
+
+  @@index([textDocumentId])
+  @@index([userId])
+  @@index([clientId])
+  @@index([textDocumentId, connected])
+}

package/src/archive/ArchivalService.ts

@@ -62,7 +62,7 @@ export class ArchivalService {
       const metadata: ArchivalMetadata = {
         documentId,
         snapshotVersion: snapshot.journalIndex || 0,
-        lamportTime: snapshot.lamportTime || 0,
+        lamportTime: snapshot.lt || 0,
         originalSize: compressionResult.originalSize,
         compressedSize: compressionResult.compressedSize,
         compressionRatio: compressionResult.ratio,

package/src/broker/InMemoryBroker.ts

@@ -49,17 +49,17 @@ export class InMemoryBroker implements RoomBroker {
 
   async setMember(
     roomId: string,
-    sessionId: string,
+    client: string,
     state: MemberState,
   ): Promise<void> {
     if (!this.members.has(roomId)) {
       this.members.set(roomId, new Map());
     }
-    this.members.get(roomId)!.set(sessionId, state);
+    this.members.get(roomId)!.set(client, state);
   }
 
-  async removeMember(roomId: string, sessionId: string): Promise<void> {
-    this.members.get(roomId)?.delete(sessionId);
+  async removeMember(roomId: string, client: string): Promise<void> {
+    this.members.get(roomId)?.delete(client);
   }
 
   async getMembers(roomId: string): Promise<Map<string, MemberState>> {

package/src/broker/types.ts

@@ -19,7 +19,7 @@ export interface SequencedMessage extends CRDTMessage {
  * Per-member state tracked by the broker.
  */
 export interface MemberState {
-  sessionId: string;
+  client: string;
   vectorClock: Record<string, number>;
   lastSeen: number;
   connected: boolean;
@@ -44,10 +44,10 @@ export interface RoomBroker {
   nextSeq(roomId: string): Promise<number>;
 
   /** Register or update a member in a room. */
-  setMember(roomId: string, sessionId: string, state: MemberState): Promise<void>;
+  setMember(roomId: string, client: string, state: MemberState): Promise<void>;
 
   /** Remove a member from a room. */
-  removeMember(roomId: string, sessionId: string): Promise<void>;
+  removeMember(roomId: string, client: string): Promise<void>;
 
   /** Get all members in a room. */
   getMembers(roomId: string): Promise<Map<string, MemberState>>;

package/src/journal/CoalescingService.ts

@@ -58,28 +58,6 @@ export interface CoalescingResult {
   reduction: { journalBatches: number; operations: number };
 }
 
-/**
- * Type for position-based text insert
- */
-interface PositionTextInsertOp {
-  otype: 'text.insert';
-  key: string;
-  path: string;
-  position: number;
-  value: string;
-}
-
-/**
- * Type for position-based text delete
- */
-interface PositionTextDeleteOp {
-  otype: 'text.delete';
-  key: string;
-  path: string;
-  position: number;
-  length: number;
-}
-
 /**
  * Operation with embedded timestamp for coalescing
  */
@@ -88,29 +66,11 @@ interface TimestampedOp {
   timestamp: number; // ms
 }
 
-/**
- * Check if an operation is a position-based text insert
- */
-function isPositionTextInsertOp(op: Operation): op is PositionTextInsertOp {
-  return op.otype === 'text.insert' &&
-    typeof (op as any).position === 'number' &&
-    typeof (op as any).value === 'string';
-}
-
-/**
- * Check if an operation is a position-based text delete
- */
-function isPositionTextDeleteOp(op: Operation): op is PositionTextDeleteOp {
-  return op.otype === 'text.delete' &&
-    typeof (op as any).position === 'number' &&
-    typeof (op as any).length === 'number';
-}
-
 /**
  * Check if an operation is a set operation
  */
 function isSetOp(op: Operation): boolean {
-  return op.otype.endsWith('.set');
+  return op.ot.endsWith('.set');
 }
 
 /**
@@ -119,184 +79,10 @@ function isSetOp(op: Operation): boolean {
  * factors together gives a different result than applying them sequentially
  */
 function isAdditiveOp(op: Operation): boolean {
-  return op.otype === 'vector3.add' ||
-         op.otype === 'number.add';
+  return op.ot === 'vector3.add' ||
+         op.ot === 'number.add';
 }
 
-/**
- * Coalesce consecutive text inserts and deletes (works with timestamped ops)
- *
- * Insert coalescing: Consecutive inserts at adjacent positions
- *   insert(10, "a"), insert(11, "b"), insert(12, "c") → insert(10, "abc")
- *
- * Delete coalescing:
- *   - Forward (Delete key): Same position
- *     del(10, 1), del(10, 1), del(10, 1) → del(10, 3)
- *   - Backward (Backspace): Position moves left by length
- *     del(10, 1), del(9, 1), del(8, 1) → del(8, 3)
- */
-function coalesceTextOps(tOps: TimestampedOp[]): TimestampedOp[] {
-  if (tOps.length === 0) return tOps;
-
-  const result: TimestampedOp[] = [];
-  let pendingInsert: { op: PositionTextInsertOp; timestamp: number } | null = null;
-  let pendingDelete: { op: PositionTextDeleteOp; timestamp: number } | null = null;
-
-  for (const tOp of tOps) {
-    const op = tOp.op;
-
-    if (isPositionTextInsertOp(op)) {
-      // Flush any pending delete
-      if (pendingDelete !== null) {
-        result.push({ op: pendingDelete.op as unknown as Operation, timestamp: pendingDelete.timestamp });
-        pendingDelete = null;
-      }
-
-      // Coalesce inserts
-      if (pendingInsert === null) {
-        pendingInsert = {
-          op: {
-            otype: 'text.insert',
-            key: op.key,
-            path: op.path,
-            position: op.position,
-            value: op.value,
-          },
-          timestamp: tOp.timestamp,
-        };
-      } else if (
-        pendingInsert.op.key === op.key &&
-        pendingInsert.op.path === op.path &&
-        pendingInsert.op.position + pendingInsert.op.value.length === op.position
-      ) {
-        // Consecutive insert - merge
-        pendingInsert = {
-          op: {
-            otype: 'text.insert',
-            key: pendingInsert.op.key,
-            path: pendingInsert.op.path,
-            position: pendingInsert.op.position,
-            value: pendingInsert.op.value + op.value,
-          },
-          timestamp: tOp.timestamp,
-        };
-      } else {
-        // Non-consecutive - flush and start new
-        result.push({ op: pendingInsert.op as unknown as Operation, timestamp: pendingInsert.timestamp });
-        pendingInsert = {
-          op: {
-            otype: 'text.insert',
-            key: op.key,
-            path: op.path,
-            position: op.position,
-            value: op.value,
-          },
-          timestamp: tOp.timestamp,
-        };
-      }
-    } else if (isPositionTextDeleteOp(op)) {
-      // Flush any pending insert
-      if (pendingInsert !== null) {
-        result.push({ op: pendingInsert.op as unknown as Operation, timestamp: pendingInsert.timestamp });
-        pendingInsert = null;
-      }
-
-      // Coalesce deletes
-      if (pendingDelete === null) {
-        pendingDelete = {
-          op: {
-            otype: 'text.delete',
-            key: op.key,
-            path: op.path,
-            position: op.position,
-            length: op.length,
-          },
-          timestamp: tOp.timestamp,
-        };
-      } else if (
-        pendingDelete.op.key === op.key &&
-        pendingDelete.op.path === op.path
-      ) {
-        // Check if this is forward deletion (same position) or backward deletion (position moves left)
-        const isForwardDelete = pendingDelete.op.position === op.position;
-        const isBackwardDelete = op.position + op.length === pendingDelete.op.position;
-
-        if (isForwardDelete) {
-          // Forward delete: accumulate lengths at same position
-          pendingDelete = {
-            op: {
-              otype: 'text.delete',
-              key: pendingDelete.op.key,
-              path: pendingDelete.op.path,
-              position: pendingDelete.op.position,
-              length: pendingDelete.op.length + op.length,
-            },
-            timestamp: tOp.timestamp,
-          };
-        } else if (isBackwardDelete) {
-          // Backward delete: position moves left, accumulate lengths
-          pendingDelete = {
-            op: {
-              otype: 'text.delete',
-              key: pendingDelete.op.key,
-              path: pendingDelete.op.path,
-              position: op.position, // use new (leftmost) position
-              length: pendingDelete.op.length + op.length,
-            },
-            timestamp: tOp.timestamp,
-          };
-        } else {
-          // Non-consecutive - flush and start new
-          result.push({ op: pendingDelete.op as unknown as Operation, timestamp: pendingDelete.timestamp });
-          pendingDelete = {
-            op: {
-              otype: 'text.delete',
-              key: op.key,
-              path: op.path,
-              position: op.position,
-              length: op.length,
-            },
-            timestamp: tOp.timestamp,
-          };
-        }
-      } else {
-        // Different key/path - flush and start new
-        result.push({ op: pendingDelete.op as unknown as Operation, timestamp: pendingDelete.timestamp });
-        pendingDelete = {
-          op: {
-            otype: 'text.delete',
-            key: op.key,
-            path: op.path,
-            position: op.position,
-            length: op.length,
-          },
-          timestamp: tOp.timestamp,
-        };
-      }
-    } else {
-      // Other operation type - flush pending
-      if (pendingInsert !== null) {
-        result.push({ op: pendingInsert.op as unknown as Operation, timestamp: pendingInsert.timestamp });
-        pendingInsert = null;
-      }
-      if (pendingDelete !== null) {
-        result.push({ op: pendingDelete.op as unknown as Operation, timestamp: pendingDelete.timestamp });
-        pendingDelete = null;
-      }
-      result.push(tOp);
-    }
-  }
-
-  // Flush any remaining pending ops
-  if (pendingInsert !== null) {
-    result.push({ op: pendingInsert.op as unknown as Operation, timestamp: pendingInsert.timestamp });
-  }
-  if (pendingDelete !== null) {
-    result.push({ op: pendingDelete.op as unknown as Operation, timestamp: pendingDelete.timestamp });
-  }
-
-  return result;
-}
 
 /**
  * Coalesce set operations with configurable strategy
@@ -427,17 +213,17 @@ function coalesceAdditiveOps(tOps: TimestampedOp[]): TimestampedOp[] {
   for (const tOp of tOps) {
     const op = tOp.op;
     if (isAdditiveOp(op)) {
-      const key = `${(op as any).key}:${(op as any).path}:${op.otype}`;
+      const key = `${(op as any).key}:${(op as any).path}:${op.ot}`;
       const existing = pendingByKey.get(key);
 
-      if (existing && existing.op.otype === op.otype) {
+      if (existing && existing.op.ot === op.ot) {
         // Merge values
-        if (op.otype === 'vector3.add') {
+        if (op.ot === 'vector3.add') {
           const va = (existing.op as any).value as [number, number, number];
           const vb = (op as any).value as [number, number, number];
           (existing.op as any).value = [va[0] + vb[0], va[1] + vb[1], va[2] + vb[2]];
           existing.timestamp = tOp.timestamp; // update to latest timestamp
-        } else if (op.otype === 'number.add') {
+        } else if (op.ot === 'number.add') {
           (existing.op as any).value = (existing.op as any).value + (op as any).value;
           existing.timestamp = tOp.timestamp;
         }
@@ -488,16 +274,16 @@ function coalesceOperations(
   // Group messages into consecutive runs from the same session
   const runs: CRDTMessage[][] = [];
   let currentRun: CRDTMessage[] = [];
-  let lastSessionId: string | null = null;
+  let lastClient: string | null = null;
 
   for (const msg of messages) {
-    if (msg.sessionId !== lastSessionId && currentRun.length > 0) {
-      // Session switch - emit current run and start new one
+    if (msg.client !== lastClient && currentRun.length > 0) {
+      // Client switch - emit current run and start new one
       runs.push(currentRun);
       currentRun = [];
     }
     currentRun.push(msg);
-    lastSessionId = msg.sessionId;
+    lastClient = msg.client;
   }
   if (currentRun.length > 0) {
     runs.push(currentRun);
@@ -510,16 +296,13 @@ function coalesceOperations(
     // Flatten all ops from this run with embedded timestamps
     let tOps: TimestampedOp[] = [];
     for (const msg of run) {
-      const timestamp = msg.timestamp * 1000; // convert to ms
+      const timestamp = msg.ts * 1000; // convert to ms
       for (const op of msg.ops) {
         tOps.push({ op, timestamp });
       }
     }
 
     // Apply coalescing in order
-    if (config.enableTextCoalesce !== false) {
-      tOps = coalesceTextOps(tOps);
-    }
     if (config.enableSetCoalesce !== false) {
       tOps = coalesceSetOps(tOps, config);
     }
@@ -564,10 +347,10 @@ export class CoalescingService {
     // Convert batches to messages
     const messages: CRDTMessage[] = batches.map(b => ({
       id: b.id,
-      sessionId: b.sessionId ?? 'unknown',
+      client: b.client ?? 'unknown',
       clock: (b.vectorClock as Record<string, number>) ?? {},
-      lamportTime: b.lamportTime ?? 0,
-      timestamp: b.persistedAt.getTime() / 1000,
+      lt: b.lamportTime ?? 0,
+      ts: b.persistedAt.getTime() / 1000,
       ops: (Array.isArray(b.operations) ? b.operations : []) as unknown as Operation[],
     }));
 
@@ -600,9 +383,9 @@ export class CoalescingService {
           await tx.journalBatch.create({
             data: {
               documentId: docId,
-              batchId: `coalesced-${msg.sessionId}-${Date.now()}-${i}`,
-              lamportTime: msg.lamportTime,
-              sessionId: msg.sessionId,
+              batchId: `coalesced-${msg.client}-${Date.now()}-${i}`,
+              lamportTime: msg.lt,
+              client: msg.client,
               vectorClock: msg.clock,
               operations: msg.ops as unknown as any[],
               startTime: now,