@vuer-ai/vuer-rtc-server 0.2.0 → 0.2.2

package/dist/compression/CompressionUtils.js

@@ -0,0 +1,90 @@
+/**
+ * Compression Utilities for S3 Cold Storage
+ *
+ * Provides gzip compression/decompression for journal snapshots
+ * when archiving to S3 cold storage. Maintains data integrity
+ * through roundtrip verification.
+ */
+import { gzipSync, gunzipSync } from 'zlib';
+/**
+ * Compress a JSON snapshot for S3 storage.
+ *
+ * @param snapshot The snapshot object to compress
+ * @returns Compression result with size metrics and ratio
+ */
+export function compressSnapshot(snapshot) {
+    // Serialize to JSON string with minimal whitespace
+    const jsonString = JSON.stringify(snapshot);
+    const originalBuffer = Buffer.from(jsonString, 'utf-8');
+    // Compress using gzip
+    const compressedBuffer = gzipSync(originalBuffer, {
+        level: 6, // Balance between compression ratio and speed
+    });
+    const originalSize = originalBuffer.byteLength;
+    const compressedSize = compressedBuffer.byteLength;
+    const ratio = (compressedSize / originalSize) * 100;
+    return {
+        compressed: compressedBuffer,
+        original: originalBuffer,
+        ratio,
+        originalSize,
+        compressedSize,
+    };
+}
+/**
+ * Decompress a snapshot from S3 storage.
+ *
+ * @param compressedBuffer The gzipped buffer from S3
+ * @returns Decompressed data with verification
+ */
+export function decompressSnapshot(compressedBuffer) {
+    try {
+        const decompressedBuffer = gunzipSync(compressedBuffer);
+        return {
+            decompressed: decompressedBuffer,
+            verified: true,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to decompress snapshot: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Verify that compression roundtrip preserves data integrity.
+ *
+ * Compresses a snapshot, then decompresses it and verifies
+ * the result matches the original. Useful for testing.
+ *
+ * @param snapshot The snapshot to verify
+ * @returns true if roundtrip preserves data, false otherwise
+ */
+export function verifyCompressionRoundtrip(snapshot) {
+    try {
+        const original = JSON.stringify(snapshot);
+        const compressed = compressSnapshot(snapshot);
+        const decompressed = decompressSnapshot(compressed.compressed);
+        const decompressedString = decompressed.decompressed.toString('utf-8');
+        return original === decompressedString;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get compression statistics for a snapshot.
+ *
+ * Returns size and compression ratio without storing data.
+ *
+ * @param snapshot The snapshot to analyze
+ * @returns Statistics including original size, compressed size, and ratio
+ */
+export function getCompressionStats(snapshot) {
+    const result = compressSnapshot(snapshot);
+    return {
+        originalSize: result.originalSize,
+        compressedSize: result.compressedSize,
+        ratio: result.ratio,
+        savedBytes: result.originalSize - result.compressedSize,
+    };
+}
+//# sourceMappingURL=CompressionUtils.js.map

package/dist/compression/CompressionUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompressionUtils.js","sourceRoot":"","sources":["../../src/compression/CompressionUtils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAe5C;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAiB;IAChD,mDAAmD;IACnD,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IAC5C,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAExD,sBAAsB;IACtB,MAAM,gBAAgB,GAAG,QAAQ,CAAC,cAAc,EAAE;QAChD,KAAK,EAAE,CAAC,EAAE,8CAA8C;KACzD,CAAC,CAAC;IAEH,MAAM,YAAY,GAAG,cAAc,CAAC,UAAU,CAAC;IAC/C,MAAM,cAAc,GAAG,gBAAgB,CAAC,UAAU,CAAC;IACnD,MAAM,KAAK,GAAG,CAAC,cAAc,GAAG,YAAY,CAAC,GAAG,GAAG,CAAC;IAEpD,OAAO;QACL,UAAU,EAAE,gBAAgB;QAC5B,QAAQ,EAAE,cAAc;QACxB,KAAK;QACL,YAAY;QACZ,cAAc;KACf,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,gBAAwB;IACzD,IAAI,CAAC;QACH,MAAM,kBAAkB,GAAG,UAAU,CAAC,gBAAgB,CAAC,CAAC;QACxD,OAAO;YACL,YAAY,EAAE,kBAAkB;YAChC,QAAQ,EAAE,IAAI;SACf,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,kCAAkC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC9G,CAAC;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,0BAA0B,CAAC,QAAiB;IAC1D,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC1C,MAAM,UAAU,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QAC9C,MAAM,YAAY,GAAG,kBAAkB,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC/D,MAAM,kBAAkB,GAAG,YAAY,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACvE,OAAO,QAAQ,KAAK,kBAAkB,CAAC;IACzC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAiB;IAMnD,MAAM,MAAM,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC1C,OAAO;QACL,YAAY,EAAE,MAAM,CAAC,YAAY;QACjC,cAAc,EAAE,MAAM,CAAC,cAAc;QACrC,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,UAAU,EAAE,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,cAAc;KACxD,CAAC;AACJ,CAAC"}

package/dist/compression/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compression module exports
+ *
+ * Provides gzip compression utilities for S3 cold storage archival
+ */
+export { compressSnapshot, decompressSnapshot, verifyCompressionRoundtrip, getCompressionStats, type CompressionResult, type DecompressionResult, } from './CompressionUtils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/compression/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,mBAAmB,EACnB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,uBAAuB,CAAC"}

package/dist/compression/index.js

@@ -0,0 +1,7 @@
+/**
+ * Compression module exports
+ *
+ * Provides gzip compression utilities for S3 cold storage archival
+ */
+export { compressSnapshot, decompressSnapshot, verifyCompressionRoundtrip, getCompressionStats, } from './CompressionUtils.js';
+//# sourceMappingURL=index.js.map

package/dist/compression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/compression/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,mBAAmB,GAGpB,MAAM,uBAAuB,CAAC"}

package/dist/journal/CoalescingService.d.ts

@@ -0,0 +1,63 @@
+/**
+ * CoalescingService - Merges compatible operations in journal batches
+ *
+ * Reduces journal size by:
+ * - Merging consecutive text.insert operations into multi-char inserts
+ * - Merging set operations on same (key, path) within time threshold
+ * - Merging additive operations (vector3.add, number.add)
+ */
+import type { PrismaClient } from '@prisma/client';
+/**
+ * Coalescing strategy for set operations
+ */
+export type SetCoalescingStrategy = 'last-write' | 'throttle';
+/**
+ * Per-property coalescing configuration
+ */
+export interface PropertyCoalescingConfig {
+    /** Time window for coalescing (ms) */
+    thresholdMs?: number;
+    /** Coalescing strategy */
+    strategy?: SetCoalescingStrategy;
+    /** Sampling interval for throttle strategy (ms) */
+    samplingIntervalMs?: number;
+    /** Delta threshold - only coalesce if value change is below this (for numeric values) */
+    deltaThreshold?: number;
+}
+export interface CoalescingConfig {
+    /** Default time threshold for set operations (ms) */
+    setThresholdMs?: number;
+    /** Default coalescing strategy for set operations */
+    setStrategy?: SetCoalescingStrategy;
+    /** Default sampling interval for throttle strategy (ms) */
+    samplingIntervalMs?: number;
+    /** Per-property overrides (key format: "key.path" or "*.path" for all keys) */
+    propertyConfig?: Record<string, PropertyCoalescingConfig>;
+    enableTextCoalesce?: boolean;
+    enableSetCoalesce?: boolean;
+    enableVectorCoalesce?: boolean;
+}
+export interface CoalescingResult {
+    ok: boolean;
+    before: {
+        journalBatches: number;
+        operations: number;
+    };
+    after: {
+        journalBatches: number;
+        operations: number;
+    };
+    reduction: {
+        journalBatches: number;
+        operations: number;
+    };
+}
+export declare class CoalescingService {
+    private prisma;
+    constructor(prisma: PrismaClient);
+    /**
+     * Coalesce operations in a document's journal
+     */
+    coalesce(docId: string, config?: CoalescingConfig): Promise<CoalescingResult>;
+}
+//# sourceMappingURL=CoalescingService.d.ts.map

package/dist/journal/CoalescingService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoalescingService.d.ts","sourceRoot":"","sources":["../../src/journal/CoalescingService.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAOnD;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAC7B,YAAY,GACZ,UAAU,CAAC;AAEf;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,sCAAsC;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,mDAAmD;IACnD,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,yFAAyF;IACzF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC,2DAA2D;IAC3D,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,+EAA+E;IAC/E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;IAG1D,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACvD,KAAK,EAAE;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;IACtD,SAAS,EAAE;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3D;AAueD,qBAAa,iBAAiB;IAChB,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAExC;;OAEG;IACG,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,gBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA0ExF"}

package/dist/journal/CoalescingService.js

@@ -0,0 +1,507 @@
+/**
+ * CoalescingService - Merges compatible operations in journal batches
+ *
+ * Reduces journal size by:
+ * - Merging consecutive text.insert operations into multi-char inserts
+ * - Merging set operations on same (key, path) within time threshold
+ * - Merging additive operations (vector3.add, number.add)
+ */
+// Default time threshold for set operation coalescing (ms)
+const DEFAULT_SET_THRESHOLD_MS = 5000;
+const DEFAULT_SAMPLING_INTERVAL_MS = 100;
+/**
+ * Check if an operation is a position-based text insert
+ */
+function isPositionTextInsertOp(op) {
+    return op.otype === 'text.insert' &&
+        typeof op.position === 'number' &&
+        typeof op.value === 'string';
+}
+/**
+ * Check if an operation is a position-based text delete
+ */
+function isPositionTextDeleteOp(op) {
+    return op.otype === 'text.delete' &&
+        typeof op.position === 'number' &&
+        typeof op.length === 'number';
+}
+/**
+ * Check if an operation is a set operation
+ */
+function isSetOp(op) {
+    return op.otype.endsWith('.set');
+}
+/**
+ * Check if an operation is an additive operation
+ * Note: number.multiply is NOT included because multiplying multiple
+ * factors together gives a different result than applying them sequentially
+ */
+function isAdditiveOp(op) {
+    return op.otype === 'vector3.add' ||
+        op.otype === '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) {
+    if (tOps.length === 0)
+        return tOps;
+    const result = [];
+    let pendingInsert = null;
+    let pendingDelete = 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, 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, 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, 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, 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, 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, timestamp: pendingInsert.timestamp });
+                pendingInsert = null;
+            }
+            if (pendingDelete !== null) {
+                result.push({ op: pendingDelete.op, timestamp: pendingDelete.timestamp });
+                pendingDelete = null;
+            }
+            result.push(tOp);
+        }
+    }
+    // Flush any remaining pending ops
+    if (pendingInsert !== null) {
+        result.push({ op: pendingInsert.op, timestamp: pendingInsert.timestamp });
+    }
+    if (pendingDelete !== null) {
+        result.push({ op: pendingDelete.op, timestamp: pendingDelete.timestamp });
+    }
+    return result;
+}
+/**
+ * Coalesce set operations with configurable strategy
+ * Uses embedded timestamps in TimestampedOp for correct tracking
+ *
+ * Strategies:
+ * - 'last-write': Keep only the last write within threshold (default)
+ * - 'throttle': Sample at regular intervals (samplingIntervalMs)
+ */
+function coalesceSetOps(tOps, config) {
+    if (tOps.length === 0)
+        return tOps;
+    const thresholdMs = config.setThresholdMs ?? DEFAULT_SET_THRESHOLD_MS;
+    const strategy = config.setStrategy ?? 'last-write';
+    const samplingIntervalMs = config.samplingIntervalMs ?? DEFAULT_SAMPLING_INTERVAL_MS;
+    if (strategy === 'last-write') {
+        return coalesceSetOpsLastWrite(tOps, thresholdMs);
+    }
+    else if (strategy === 'throttle') {
+        return coalesceSetOpsThrottle(tOps, thresholdMs, samplingIntervalMs);
+    }
+    return tOps;
+}
+/**
+ * Last-write strategy: Keep only the last write within threshold
+ */
+function coalesceSetOpsLastWrite(tOps, thresholdMs) {
+    const result = [];
+    const lastSetByKey = new Map();
+    for (const tOp of tOps) {
+        const op = tOp.op;
+        const timestamp = tOp.timestamp;
+        if (isSetOp(op)) {
+            const key = `${op.key}:${op.path}`;
+            const existing = lastSetByKey.get(key);
+            if (existing && (timestamp - existing.tOp.timestamp) <= thresholdMs) {
+                // Within threshold - replace existing with new
+                result[existing.resultIndex] = tOp;
+                lastSetByKey.set(key, { tOp, resultIndex: existing.resultIndex });
+            }
+            else {
+                // New set or outside threshold
+                const resultIndex = result.length;
+                result.push(tOp);
+                lastSetByKey.set(key, { tOp, resultIndex });
+            }
+        }
+        else {
+            result.push(tOp);
+        }
+    }
+    return result;
+}
+/**
+ * Throttle strategy: Sample at regular intervals
+ * Keep one sample per interval, dropping intermediate updates
+ */
+function coalesceSetOpsThrottle(tOps, thresholdMs, samplingIntervalMs) {
+    const result = [];
+    const lastSampleByKey = new Map();
+    for (const tOp of tOps) {
+        const op = tOp.op;
+        const timestamp = tOp.timestamp;
+        if (isSetOp(op)) {
+            const key = `${op.key}:${op.path}`;
+            const existing = lastSampleByKey.get(key);
+            if (!existing) {
+                // First sample for this key
+                const resultIndex = result.length;
+                result.push(tOp);
+                lastSampleByKey.set(key, {
+                    tOp,
+                    resultIndex,
+                    intervalStart: Math.floor(timestamp / samplingIntervalMs) * samplingIntervalMs,
+                });
+            }
+            else {
+                const currentInterval = Math.floor(timestamp / samplingIntervalMs) * samplingIntervalMs;
+                const timeSinceFirstSample = timestamp - existing.intervalStart;
+                if (currentInterval === existing.intervalStart) {
+                    // Same interval - replace with latest
+                    result[existing.resultIndex] = tOp;
+                    lastSampleByKey.set(key, { ...existing, tOp });
+                }
+                else if (timeSinceFirstSample <= thresholdMs) {
+                    // New interval, still within threshold - add new sample
+                    const resultIndex = result.length;
+                    result.push(tOp);
+                    lastSampleByKey.set(key, { tOp, resultIndex, intervalStart: currentInterval });
+                }
+                else {
+                    // Outside threshold - reset
+                    const resultIndex = result.length;
+                    result.push(tOp);
+                    lastSampleByKey.set(key, { tOp, resultIndex, intervalStart: currentInterval });
+                }
+            }
+        }
+        else {
+            result.push(tOp);
+        }
+    }
+    return result;
+}
+/**
+ * Coalesce additive operations (works with timestamped ops)
+ */
+function coalesceAdditiveOps(tOps) {
+    if (tOps.length === 0)
+        return tOps;
+    const result = [];
+    const pendingByKey = new Map();
+    for (const tOp of tOps) {
+        const op = tOp.op;
+        if (isAdditiveOp(op)) {
+            const key = `${op.key}:${op.path}:${op.otype}`;
+            const existing = pendingByKey.get(key);
+            if (existing && existing.op.otype === op.otype) {
+                // Merge values
+                if (op.otype === 'vector3.add') {
+                    const va = existing.op.value;
+                    const vb = op.value;
+                    existing.op.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') {
+                    existing.op.value = existing.op.value + op.value;
+                    existing.timestamp = tOp.timestamp;
+                }
+            }
+            else {
+                if (existing) {
+                    result.push(existing);
+                }
+                pendingByKey.set(key, { op: { ...op }, timestamp: tOp.timestamp });
+            }
+        }
+        else {
+            // Flush all pending additive ops
+            for (const pending of pendingByKey.values()) {
+                result.push(pending);
+            }
+            pendingByKey.clear();
+            result.push(tOp);
+        }
+    }
+    // Flush remaining
+    for (const pending of pendingByKey.values()) {
+        result.push(pending);
+    }
+    return result;
+}
+/**
+ * Coalesce operations in a message array
+ *
+ * IMPORTANT: Preserves interleaved order to maintain causality.
+ * Groups messages into consecutive runs from the same session, then coalesces
+ * each run separately. This ensures Lamport's "happened-before" relation is preserved.
+ *
+ * Example:
+ *   Input:  [alice-msg1, alice-msg2, bob-msg3, alice-msg4]
+ *   Output: [alice-run1, bob-run2, alice-run3]
+ *
+ * This prevents the bug where all operations from a session get the last message's
+ * lamportTime, which breaks LWW conflict resolution.
+ */
+function coalesceOperations(messages, config) {
+    if (messages.length === 0)
+        return [];
+    // Group messages into consecutive runs from the same session
+    const runs = [];
+    let currentRun = [];
+    let lastSessionId = null;
+    for (const msg of messages) {
+        if (msg.sessionId !== lastSessionId && currentRun.length > 0) {
+            // Session switch - emit current run and start new one
+            runs.push(currentRun);
+            currentRun = [];
+        }
+        currentRun.push(msg);
+        lastSessionId = msg.sessionId;
+    }
+    if (currentRun.length > 0) {
+        runs.push(currentRun);
+    }
+    // Coalesce each run separately
+    const coalescedMessages = [];
+    for (const run of runs) {
+        // Flatten all ops from this run with embedded timestamps
+        let tOps = [];
+        for (const msg of run) {
+            const timestamp = msg.timestamp * 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);
+        }
+        if (config.enableVectorCoalesce !== false) {
+            tOps = coalesceAdditiveOps(tOps);
+        }
+        // Extract final ops
+        const allOps = tOps.map(t => t.op);
+        if (allOps.length === 0)
+            continue;
+        // Rebuild message for this run - use the last message's metadata
+        const lastMsg = run[run.length - 1];
+        coalescedMessages.push({
+            ...lastMsg,
+            ops: allOps,
+        });
+    }
+    return coalescedMessages;
+}
+export class CoalescingService {
+    prisma;
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    /**
+     * Coalesce operations in a document's journal
+     */
+    async coalesce(docId, config = {}) {
+        // Get all journal batches
+        const batches = await this.prisma.journalBatch.findMany({
+            where: { documentId: docId },
+            orderBy: { lamportTime: 'asc' },
+        });
+        const beforeOpsCount = batches.reduce((sum, b) => {
+            const ops = Array.isArray(b.operations) ? b.operations : [];
+            return sum + ops.length;
+        }, 0);
+        // Convert batches to messages
+        const messages = batches.map(b => ({
+            id: b.id,
+            sessionId: b.sessionId ?? 'unknown',
+            clock: b.vectorClock ?? {},
+            lamportTime: b.lamportTime ?? 0,
+            timestamp: b.persistedAt.getTime() / 1000,
+            ops: (Array.isArray(b.operations) ? b.operations : []),
+        }));
+        // Coalesce
+        const coalesced = coalesceOperations(messages, config);
+        // Count ops after
+        const afterOpsCount = coalesced.reduce((sum, m) => sum + m.ops.length, 0);
+        // If no reduction, skip update
+        if (afterOpsCount >= beforeOpsCount) {
+            return {
+                ok: true,
+                before: { journalBatches: batches.length, operations: beforeOpsCount },
+                after: { journalBatches: batches.length, operations: beforeOpsCount },
+                reduction: { journalBatches: 0, operations: 0 },
+            };
+        }
+        // Delete old batches and create new ones (one per session)
+        const now = new Date();
+        await this.prisma.$transaction(async (tx) => {
+            // Delete old batches
+            await tx.journalBatch.deleteMany({ where: { documentId: docId } });
+            // Create coalesced batches - one per session
+            for (let i = 0; i < coalesced.length; i++) {
+                const msg = coalesced[i];
+                if (msg.ops.length > 0) {
+                    await tx.journalBatch.create({
+                        data: {
+                            documentId: docId,
+                            batchId: `coalesced-${msg.sessionId}-${Date.now()}-${i}`,
+                            lamportTime: msg.lamportTime,
+                            sessionId: msg.sessionId,
+                            vectorClock: msg.clock,
+                            operations: msg.ops,
+                            startTime: now,
+                            endTime: now,
+                        },
+                    });
+                }
+            }
+        });
+        return {
+            ok: true,
+            before: { journalBatches: batches.length, operations: beforeOpsCount },
+            after: { journalBatches: coalesced.length, operations: afterOpsCount },
+            reduction: {
+                journalBatches: batches.length - coalesced.length,
+                operations: beforeOpsCount - afterOpsCount,
+            },
+        };
+    }
+}
+//# sourceMappingURL=CoalescingService.js.map