@vuer-ai/vuer-rtc 0.5.4 → 0.6.0

package/dist/client/coalescence/index.d.ts

@@ -6,4 +6,7 @@
 export { coalesceOperations, registerCoalescer, getCoalescer, hasCoalescer, type CoalesceOptions, type CoalesceHandler, type TypeGuard, } from './registry.js';
 export { coalesceTextInserts, isTextInsertOp, type TextInsertOp } from './textInserts.js';
 export { coalesceTextDeletes, isTextDeleteOp, type TextDeleteOp } from './textDeletes.js';
+export { coalesceNumberAdds, isNumberAddOp, type NumberAddOp } from './numberOperations.js';
+export { coalesceVector3Adds, isVector3AddOp, type Vector3AddOp } from './vector3Operations.js';
+export { coalesceLWWSets, isLWWSetOp, type LWWSetOp } from './lwwOperations.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/client/coalescence/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/coalescence/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,SAAS,GACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/coalescence/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,SAAS,GACf,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/client/coalescence/index.js

@@ -6,4 +6,7 @@
 export { coalesceOperations, registerCoalescer, getCoalescer, hasCoalescer, } from './registry.js';
 export { coalesceTextInserts, isTextInsertOp } from './textInserts.js';
 export { coalesceTextDeletes, isTextDeleteOp } from './textDeletes.js';
+export { coalesceNumberAdds, isNumberAddOp } from './numberOperations.js';
+export { coalesceVector3Adds, isVector3AddOp } from './vector3Operations.js';
+export { coalesceLWWSets, isLWWSetOp } from './lwwOperations.js';
 //# sourceMappingURL=index.js.map

package/dist/client/coalescence/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/client/coalescence/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,YAAY,GAIb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/client/coalescence/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,kBAAkB,EAClB,iBAAiB,EACjB,YAAY,EACZ,YAAY,GAIb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAqB,MAAM,kBAAkB,CAAC;AAC1F,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAoB,MAAM,uBAAuB,CAAC;AAC5F,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAqB,MAAM,wBAAwB,CAAC;AAChG,OAAO,EAAE,eAAe,EAAE,UAAU,EAAiB,MAAM,oBAAoB,CAAC"}

package/dist/client/coalescence/lwwOperations.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Last-Write-Wins (LWW) Operations Coalescence
+ *
+ * Generic coalescer for all *.set operations.
+ * Set operations follow Last-Write-Wins semantics - only the last value matters.
+ *
+ * Supported operations:
+ * - number.set, string.set, boolean.set
+ * - vector3.set, euler.set, quaternion.set, color.set
+ * - array.set, object.set
+ */
+import type { Operation, NumberSetOp, StringSetOp, BooleanSetOp, Vector3SetOp, EulerSetOp, QuaternionSetOp, ColorSetOp, ArraySetOp, ObjectSetOp } from '../../operations/OperationTypes.js';
+import type { CoalesceOptions } from './registry.js';
+export type LWWSetOp = NumberSetOp | StringSetOp | BooleanSetOp | Vector3SetOp | EulerSetOp | QuaternionSetOp | ColorSetOp | ArraySetOp | ObjectSetOp;
+/**
+ * Check if an operation is a *.set operation
+ */
+export declare function isLWWSetOp(op: Operation): op is LWWSetOp;
+/**
+ * Coalesce consecutive *.set operations using Last-Write-Wins semantics.
+ *
+ * Since set operations follow LWW, only the last value in a sequence matters.
+ * We can safely discard all but the last operation for the same target.
+ *
+ * Example:
+ * Input:  [set(key:"cube", path:"color", value:"red"), set(key:"cube", path:"color", value:"blue")]
+ * Output: [set(key:"cube", path:"color", value:"blue")]
+ *
+ * @param ops - Array of *.set operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for Last-Write-Wins operations.
+ *   LWW semantics mean only the final value matters, regardless of timing,
+ *   so we keep only the last operation on each target.
+ * @returns New array with coalesced operations
+ */
+export declare function coalesceLWWSets(ops: LWWSetOp[], options?: CoalesceOptions): LWWSetOp[];
+//# sourceMappingURL=lwwOperations.d.ts.map

package/dist/client/coalescence/lwwOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lwwOperations.d.ts","sourceRoot":"","sources":["../../../src/client/coalescence/lwwOperations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,eAAe,EACf,UAAU,EACV,UAAU,EACV,WAAW,EACZ,MAAM,oCAAoC,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,MAAM,MAAM,QAAQ,GAChB,WAAW,GACX,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,UAAU,GACV,eAAe,GACf,UAAU,GACV,UAAU,GACV,WAAW,CAAC;AAEhB;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,SAAS,GAAG,EAAE,IAAI,QAAQ,CAMxD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,QAAQ,EAAE,EACf,OAAO,GAAE,eAAoB,GAC5B,QAAQ,EAAE,CAkCZ"}

package/dist/client/coalescence/lwwOperations.js

@@ -0,0 +1,69 @@
+/**
+ * Last-Write-Wins (LWW) Operations Coalescence
+ *
+ * Generic coalescer for all *.set operations.
+ * Set operations follow Last-Write-Wins semantics - only the last value matters.
+ *
+ * Supported operations:
+ * - number.set, string.set, boolean.set
+ * - vector3.set, euler.set, quaternion.set, color.set
+ * - array.set, object.set
+ */
+/**
+ * Check if an operation is a *.set operation
+ */
+export function isLWWSetOp(op) {
+    return (typeof op.otype === 'string' &&
+        op.otype.endsWith('.set') &&
+        op.value !== undefined);
+}
+/**
+ * Coalesce consecutive *.set operations using Last-Write-Wins semantics.
+ *
+ * Since set operations follow LWW, only the last value in a sequence matters.
+ * We can safely discard all but the last operation for the same target.
+ *
+ * Example:
+ * Input:  [set(key:"cube", path:"color", value:"red"), set(key:"cube", path:"color", value:"blue")]
+ * Output: [set(key:"cube", path:"color", value:"blue")]
+ *
+ * @param ops - Array of *.set operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for Last-Write-Wins operations.
+ *   LWW semantics mean only the final value matters, regardless of timing,
+ *   so we keep only the last operation on each target.
+ * @returns New array with coalesced operations
+ */
+export function coalesceLWWSets(ops, options = {}) {
+    if (ops.length === 0)
+        return ops;
+    const result = [];
+    let pending = null;
+    for (const op of ops) {
+        if (pending === null) {
+            // Start new pending set
+            pending = { ...op };
+        }
+        else {
+            // Check if operations target the same property AND same operation type
+            const sameTarget = pending.key === op.key &&
+                pending.path === op.path &&
+                pending.otype === op.otype;
+            if (sameTarget) {
+                // LWW: Replace with newer value
+                pending = { ...op };
+            }
+            else {
+                // Different target or type - flush pending and start new
+                result.push(pending);
+                pending = { ...op };
+            }
+        }
+    }
+    // Flush any remaining pending set
+    if (pending !== null) {
+        result.push(pending);
+    }
+    return result;
+}
+//# sourceMappingURL=lwwOperations.js.map

package/dist/client/coalescence/lwwOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lwwOperations.js","sourceRoot":"","sources":["../../../src/client/coalescence/lwwOperations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AA4BH;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,EAAa;IACtC,OAAO,CACL,OAAO,EAAE,CAAC,KAAK,KAAK,QAAQ;QAC5B,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC;QACxB,EAAU,CAAC,KAAK,KAAK,SAAS,CAChC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC7B,GAAe,EACf,UAA2B,EAAE;IAE7B,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAEjC,MAAM,MAAM,GAAe,EAAE,CAAC;IAC9B,IAAI,OAAO,GAAoB,IAAI,CAAC;IAEpC,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,wBAAwB;YACxB,OAAO,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,uEAAuE;YACvE,MAAM,UAAU,GACd,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG;gBACtB,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI;gBACxB,OAAO,CAAC,KAAK,KAAK,EAAE,CAAC,KAAK,CAAC;YAE7B,IAAI,UAAU,EAAE,CAAC;gBACf,gCAAgC;gBAChC,OAAO,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,yDAAyD;gBACzD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACrB,OAAO,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;YACtB,CAAC;QACH,CAAC;IACH,CAAC;IAED,kCAAkC;IAClC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/client/coalescence/numberOperations.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Number Operations Coalescence
+ *
+ * Merges consecutive number.add operations on the same target.
+ * Addition is commutative, so we can safely merge multiple adds into one.
+ */
+import type { Operation, NumberAddOp } from '../../operations/OperationTypes.js';
+import type { CoalesceOptions } from './registry.js';
+export type { NumberAddOp };
+/**
+ * Check if an operation is a number.add operation
+ */
+export declare function isNumberAddOp(op: Operation): op is NumberAddOp;
+/**
+ * Coalesce consecutive number.add operations.
+ *
+ * Since addition is commutative (a + b = b + a), we can safely merge
+ * all consecutive adds into a single operation by summing the values.
+ *
+ * Example:
+ * Input:  [add(key:"score", path:"value", value:10), add(key:"score", path:"value", value:5)]
+ * Output: [add(key:"score", path:"value", value:15)]
+ *
+ * @param ops - Array of number.add operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for commutative operations like addition.
+ *   Mathematically, a+b = b+a regardless of when they occurred, so we merge
+ *   all consecutive operations on the same target without time restrictions.
+ * @returns New array with coalesced operations
+ */
+export declare function coalesceNumberAdds(ops: NumberAddOp[], options?: CoalesceOptions): NumberAddOp[];
+//# sourceMappingURL=numberOperations.d.ts.map

package/dist/client/coalescence/numberOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberOperations.d.ts","sourceRoot":"","sources":["../../../src/client/coalescence/numberOperations.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,EAAE,IAAI,WAAW,CAK9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,WAAW,EAAE,EAClB,OAAO,GAAE,eAAoB,GAC5B,WAAW,EAAE,CAoCf"}

package/dist/client/coalescence/numberOperations.js

@@ -0,0 +1,66 @@
+/**
+ * Number Operations Coalescence
+ *
+ * Merges consecutive number.add operations on the same target.
+ * Addition is commutative, so we can safely merge multiple adds into one.
+ */
+/**
+ * Check if an operation is a number.add operation
+ */
+export function isNumberAddOp(op) {
+    return (op.otype === 'number.add' &&
+        typeof op.value === 'number');
+}
+/**
+ * Coalesce consecutive number.add operations.
+ *
+ * Since addition is commutative (a + b = b + a), we can safely merge
+ * all consecutive adds into a single operation by summing the values.
+ *
+ * Example:
+ * Input:  [add(key:"score", path:"value", value:10), add(key:"score", path:"value", value:5)]
+ * Output: [add(key:"score", path:"value", value:15)]
+ *
+ * @param ops - Array of number.add operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for commutative operations like addition.
+ *   Mathematically, a+b = b+a regardless of when they occurred, so we merge
+ *   all consecutive operations on the same target without time restrictions.
+ * @returns New array with coalesced operations
+ */
+export function coalesceNumberAdds(ops, options = {}) {
+    if (ops.length === 0)
+        return ops;
+    const result = [];
+    let pending = null;
+    for (const op of ops) {
+        if (pending === null) {
+            // Start new pending add
+            pending = { ...op };
+        }
+        else {
+            // Check if operations target the same property
+            const sameTarget = pending.key === op.key && pending.path === op.path;
+            if (sameTarget) {
+                // Merge operations by summing values
+                pending = {
+                    otype: 'number.add',
+                    key: pending.key,
+                    path: pending.path,
+                    value: pending.value + op.value,
+                };
+            }
+            else {
+                // Different target - flush pending and start new
+                result.push(pending);
+                pending = { ...op };
+            }
+        }
+    }
+    // Flush any remaining pending add
+    if (pending !== null) {
+        result.push(pending);
+    }
+    return result;
+}
+//# sourceMappingURL=numberOperations.js.map

package/dist/client/coalescence/numberOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberOperations.js","sourceRoot":"","sources":["../../../src/client/coalescence/numberOperations.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,EAAa;IACzC,OAAO,CACL,EAAE,CAAC,KAAK,KAAK,YAAY;QACzB,OAAQ,EAAU,CAAC,KAAK,KAAK,QAAQ,CACtC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,kBAAkB,CAChC,GAAkB,EAClB,UAA2B,EAAE;IAE7B,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAEjC,MAAM,MAAM,GAAkB,EAAE,CAAC;IACjC,IAAI,OAAO,GAAuB,IAAI,CAAC;IAEvC,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,wBAAwB;YACxB,OAAO,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,+CAA+C;YAC/C,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,IAAI,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,CAAC;YAEtE,IAAI,UAAU,EAAE,CAAC;gBACf,qCAAqC;gBACrC,OAAO,GAAG;oBACR,KAAK,EAAE,YAAY;oBACnB,GAAG,EAAE,OAAO,CAAC,GAAG;oBAChB,IAAI,EAAE,OAAO,CAAC,IAAI;oBAClB,KAAK,EAAE,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC,KAAK;iBAChC,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,iDAAiD;gBACjD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACrB,OAAO,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;YACtB,CAAC;QACH,CAAC;IACH,CAAC;IAED,kCAAkC;IAClC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/client/coalescence/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/client/coalescence/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAIpE,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,CAC7D,GAAG,EAAE,CAAC,EAAE,EACR,OAAO,EAAE,eAAe,KACrB,CAAC,EAAE,CAAC;AAET;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,CAAC,EAAE,EAAE,SAAS,KAAK,EAAE,IAAI,CAAC,CAAC;AAEpF;;GAEG;AACH,UAAU,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACrD,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;CAC7B;AAOD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,SAAS,EACnD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,IAAI,CAKN;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAErE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,SAAS,EAAE,EAChB,OAAO,GAAE,eAAoB,GAC5B,SAAS,EAAE,CAoDb"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/client/coalescence/registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAOpE,MAAM,WAAW,eAAe;IAC9B,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,CAC7D,GAAG,EAAE,CAAC,EAAE,EACR,OAAO,EAAE,eAAe,KACrB,CAAC,EAAE,CAAC;AAET;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,CAAC,EAAE,EAAE,SAAS,KAAK,EAAE,IAAI,CAAC,CAAC;AAEpF;;GAEG;AACH,UAAU,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACrD,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACpB,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;CAC7B;AAOD;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,SAAS,EACnD,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAC1B,IAAI,CAKN;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAErE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,SAAS,EAAE,EAChB,OAAO,GAAE,eAAoB,GAC5B,SAAS,EAAE,CAoDb"}

package/dist/client/coalescence/registry.js

@@ -6,6 +6,9 @@
  */
 import { coalesceTextInserts, isTextInsertOp } from './textInserts.js';
 import { coalesceTextDeletes, isTextDeleteOp } from './textDeletes.js';
+import { coalesceNumberAdds, isNumberAddOp } from './numberOperations.js';
+import { coalesceVector3Adds, isVector3AddOp } from './vector3Operations.js';
+import { coalesceLWWSets, isLWWSetOp } from './lwwOperations.js';
 /**
  * Global coalescence registry
  */
@@ -92,4 +95,21 @@ export function coalesceOperations(ops, options = {}) {
 // Register built-in coalescers
 registerCoalescer('text.insert', isTextInsertOp, coalesceTextInserts);
 registerCoalescer('text.delete', isTextDeleteOp, coalesceTextDeletes);
+registerCoalescer('number.add', isNumberAddOp, coalesceNumberAdds);
+registerCoalescer('vector3.add', isVector3AddOp, coalesceVector3Adds);
+// Register LWW coalescer for all *.set operations
+const LWW_SET_OPERATIONS = [
+    'number.set',
+    'string.set',
+    'boolean.set',
+    'vector3.set',
+    'euler.set',
+    'quaternion.set',
+    'color.set',
+    'array.set',
+    'object.set',
+];
+for (const otype of LWW_SET_OPERATIONS) {
+    registerCoalescer(otype, isLWWSetOp, coalesceLWWSets);
+}
 //# sourceMappingURL=registry.js.map

package/dist/client/coalescence/registry.js.map

@@ -1 +1 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/client/coalescence/registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/client/coalescence/registry.ts"],"names":[],"mappings":"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"}

package/dist/client/coalescence/vector3Operations.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Vector3 Operations Coalescence
+ *
+ * Merges consecutive vector3.add operations on the same target.
+ * Component-wise addition is commutative, so we can safely merge multiple adds.
+ */
+import type { Operation, Vector3AddOp } from '../../operations/OperationTypes.js';
+import type { CoalesceOptions } from './registry.js';
+export type { Vector3AddOp };
+/**
+ * Check if an operation is a vector3.add operation
+ */
+export declare function isVector3AddOp(op: Operation): op is Vector3AddOp;
+/**
+ * Coalesce consecutive vector3.add operations.
+ *
+ * Since component-wise addition is commutative, we can safely merge
+ * all consecutive adds into a single operation by summing the vectors.
+ *
+ * Example:
+ * Input:  [add(key:"player", path:"position", value:[1,0,0]), add(key:"player", path:"position", value:[0,2,0])]
+ * Output: [add(key:"player", path:"position", value:[1,2,0])]
+ *
+ * @param ops - Array of vector3.add operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for commutative operations like vector addition.
+ *   Component-wise addition is commutative regardless of timing, so we merge
+ *   all consecutive operations on the same target without time restrictions.
+ * @returns New array with coalesced operations
+ */
+export declare function coalesceVector3Adds(ops: Vector3AddOp[], options?: CoalesceOptions): Vector3AddOp[];
+//# sourceMappingURL=vector3Operations.d.ts.map

package/dist/client/coalescence/vector3Operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector3Operations.d.ts","sourceRoot":"","sources":["../../../src/client/coalescence/vector3Operations.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,YAAY,EAAE,YAAY,EAAE,CAAC;AAE7B;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,SAAS,GAAG,EAAE,IAAI,YAAY,CAMhE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,YAAY,EAAE,EACnB,OAAO,GAAE,eAAoB,GAC5B,YAAY,EAAE,CAwChB"}

package/dist/client/coalescence/vector3Operations.js

@@ -0,0 +1,71 @@
+/**
+ * Vector3 Operations Coalescence
+ *
+ * Merges consecutive vector3.add operations on the same target.
+ * Component-wise addition is commutative, so we can safely merge multiple adds.
+ */
+/**
+ * Check if an operation is a vector3.add operation
+ */
+export function isVector3AddOp(op) {
+    return (op.otype === 'vector3.add' &&
+        Array.isArray(op.value) &&
+        op.value.length === 3);
+}
+/**
+ * Coalesce consecutive vector3.add operations.
+ *
+ * Since component-wise addition is commutative, we can safely merge
+ * all consecutive adds into a single operation by summing the vectors.
+ *
+ * Example:
+ * Input:  [add(key:"player", path:"position", value:[1,0,0]), add(key:"player", path:"position", value:[0,2,0])]
+ * Output: [add(key:"player", path:"position", value:[1,2,0])]
+ *
+ * @param ops - Array of vector3.add operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for commutative operations like vector addition.
+ *   Component-wise addition is commutative regardless of timing, so we merge
+ *   all consecutive operations on the same target without time restrictions.
+ * @returns New array with coalesced operations
+ */
+export function coalesceVector3Adds(ops, options = {}) {
+    if (ops.length === 0)
+        return ops;
+    const result = [];
+    let pending = null;
+    for (const op of ops) {
+        if (pending === null) {
+            // Start new pending add (copy value array to avoid mutations)
+            pending = { ...op, value: [...op.value] };
+        }
+        else {
+            // Check if operations target the same property
+            const sameTarget = pending.key === op.key && pending.path === op.path;
+            if (sameTarget) {
+                // Merge operations by summing vectors component-wise
+                pending = {
+                    otype: 'vector3.add',
+                    key: pending.key,
+                    path: pending.path,
+                    value: [
+                        pending.value[0] + op.value[0],
+                        pending.value[1] + op.value[1],
+                        pending.value[2] + op.value[2],
+                    ],
+                };
+            }
+            else {
+                // Different target - flush pending and start new
+                result.push(pending);
+                pending = { ...op, value: [...op.value] };
+            }
+        }
+    }
+    // Flush any remaining pending add
+    if (pending !== null) {
+        result.push(pending);
+    }
+    return result;
+}
+//# sourceMappingURL=vector3Operations.js.map

package/dist/client/coalescence/vector3Operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector3Operations.js","sourceRoot":"","sources":["../../../src/client/coalescence/vector3Operations.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,EAAa;IAC1C,OAAO,CACL,EAAE,CAAC,KAAK,KAAK,aAAa;QAC1B,KAAK,CAAC,OAAO,CAAE,EAAU,CAAC,KAAK,CAAC;QAC/B,EAAU,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,CAC/B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAmB,EACnB,UAA2B,EAAE;IAE7B,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,GAAG,CAAC;IAEjC,MAAM,MAAM,GAAmB,EAAE,CAAC;IAClC,IAAI,OAAO,GAAwB,IAAI,CAAC;IAExC,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;YACrB,8DAA8D;YAC9D,OAAO,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAA6B,EAAE,CAAC;QACxE,CAAC;aAAM,CAAC;YACN,+CAA+C;YAC/C,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,IAAI,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,IAAI,CAAC;YAEtE,IAAI,UAAU,EAAE,CAAC;gBACf,qDAAqD;gBACrD,OAAO,GAAG;oBACR,KAAK,EAAE,aAAa;oBACpB,GAAG,EAAE,OAAO,CAAC,GAAG;oBAChB,IAAI,EAAE,OAAO,CAAC,IAAI;oBAClB,KAAK,EAAE;wBACL,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;wBAC9B,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;wBAC9B,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;qBAC/B;iBACF,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,iDAAiD;gBACjD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBACrB,OAAO,GAAG,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAA6B,EAAE,CAAC;YACxE,CAAC;QACH,CAAC;IACH,CAAC;IAED,kCAAkC;IAClC,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuer-ai/vuer-rtc",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "private": false,
   "type": "module",
   "description": "CRDT-based real-time collaborative data structures",

package/src/client/coalescence/index.ts

@@ -16,3 +16,6 @@ export {
 
 export { coalesceTextInserts, isTextInsertOp, type TextInsertOp } from './textInserts.js';
 export { coalesceTextDeletes, isTextDeleteOp, type TextDeleteOp } from './textDeletes.js';
+export { coalesceNumberAdds, isNumberAddOp, type NumberAddOp } from './numberOperations.js';
+export { coalesceVector3Adds, isVector3AddOp, type Vector3AddOp } from './vector3Operations.js';
+export { coalesceLWWSets, isLWWSetOp, type LWWSetOp } from './lwwOperations.js';

package/src/client/coalescence/lwwOperations.ts

@@ -0,0 +1,104 @@
+/**
+ * Last-Write-Wins (LWW) Operations Coalescence
+ *
+ * Generic coalescer for all *.set operations.
+ * Set operations follow Last-Write-Wins semantics - only the last value matters.
+ *
+ * Supported operations:
+ * - number.set, string.set, boolean.set
+ * - vector3.set, euler.set, quaternion.set, color.set
+ * - array.set, object.set
+ */
+
+import type {
+  Operation,
+  NumberSetOp,
+  StringSetOp,
+  BooleanSetOp,
+  Vector3SetOp,
+  EulerSetOp,
+  QuaternionSetOp,
+  ColorSetOp,
+  ArraySetOp,
+  ObjectSetOp,
+} from '../../operations/OperationTypes.js';
+import type { CoalesceOptions } from './registry.js';
+
+// Union of all *.set operation types
+export type LWWSetOp =
+  | NumberSetOp
+  | StringSetOp
+  | BooleanSetOp
+  | Vector3SetOp
+  | EulerSetOp
+  | QuaternionSetOp
+  | ColorSetOp
+  | ArraySetOp
+  | ObjectSetOp;
+
+/**
+ * Check if an operation is a *.set operation
+ */
+export function isLWWSetOp(op: Operation): op is LWWSetOp {
+  return (
+    typeof op.otype === 'string' &&
+    op.otype.endsWith('.set') &&
+    (op as any).value !== undefined
+  );
+}
+
+/**
+ * Coalesce consecutive *.set operations using Last-Write-Wins semantics.
+ *
+ * Since set operations follow LWW, only the last value in a sequence matters.
+ * We can safely discard all but the last operation for the same target.
+ *
+ * Example:
+ * Input:  [set(key:"cube", path:"color", value:"red"), set(key:"cube", path:"color", value:"blue")]
+ * Output: [set(key:"cube", path:"color", value:"blue")]
+ *
+ * @param ops - Array of *.set operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for Last-Write-Wins operations.
+ *   LWW semantics mean only the final value matters, regardless of timing,
+ *   so we keep only the last operation on each target.
+ * @returns New array with coalesced operations
+ */
+export function coalesceLWWSets(
+  ops: LWWSetOp[],
+  options: CoalesceOptions = {}
+): LWWSetOp[] {
+  if (ops.length === 0) return ops;
+
+  const result: LWWSetOp[] = [];
+  let pending: LWWSetOp | null = null;
+
+  for (const op of ops) {
+    if (pending === null) {
+      // Start new pending set
+      pending = { ...op };
+    } else {
+      // Check if operations target the same property AND same operation type
+      const sameTarget =
+        pending.key === op.key &&
+        pending.path === op.path &&
+        pending.otype === op.otype;
+
+      if (sameTarget) {
+        // LWW: Replace with newer value
+        pending = { ...op };
+      } else {
+        // Different target or type - flush pending and start new
+        result.push(pending);
+        pending = { ...op };
+      }
+    }
+  }
+
+  // Flush any remaining pending set
+  if (pending !== null) {
+    result.push(pending);
+  }
+
+  return result;
+}

package/src/client/coalescence/numberOperations.ts

@@ -0,0 +1,80 @@
+/**
+ * Number Operations Coalescence
+ *
+ * Merges consecutive number.add operations on the same target.
+ * Addition is commutative, so we can safely merge multiple adds into one.
+ */
+
+import type { Operation, NumberAddOp } from '../../operations/OperationTypes.js';
+import type { CoalesceOptions } from './registry.js';
+
+// Re-export type for convenience
+export type { NumberAddOp };
+
+/**
+ * Check if an operation is a number.add operation
+ */
+export function isNumberAddOp(op: Operation): op is NumberAddOp {
+  return (
+    op.otype === 'number.add' &&
+    typeof (op as any).value === 'number'
+  );
+}
+
+/**
+ * Coalesce consecutive number.add operations.
+ *
+ * Since addition is commutative (a + b = b + a), we can safely merge
+ * all consecutive adds into a single operation by summing the values.
+ *
+ * Example:
+ * Input:  [add(key:"score", path:"value", value:10), add(key:"score", path:"value", value:5)]
+ * Output: [add(key:"score", path:"value", value:15)]
+ *
+ * @param ops - Array of number.add operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for commutative operations like addition.
+ *   Mathematically, a+b = b+a regardless of when they occurred, so we merge
+ *   all consecutive operations on the same target without time restrictions.
+ * @returns New array with coalesced operations
+ */
+export function coalesceNumberAdds(
+  ops: NumberAddOp[],
+  options: CoalesceOptions = {}
+): NumberAddOp[] {
+  if (ops.length === 0) return ops;
+
+  const result: NumberAddOp[] = [];
+  let pending: NumberAddOp | null = null;
+
+  for (const op of ops) {
+    if (pending === null) {
+      // Start new pending add
+      pending = { ...op };
+    } else {
+      // Check if operations target the same property
+      const sameTarget = pending.key === op.key && pending.path === op.path;
+
+      if (sameTarget) {
+        // Merge operations by summing values
+        pending = {
+          otype: 'number.add',
+          key: pending.key,
+          path: pending.path,
+          value: pending.value + op.value,
+        };
+      } else {
+        // Different target - flush pending and start new
+        result.push(pending);
+        pending = { ...op };
+      }
+    }
+  }
+
+  // Flush any remaining pending add
+  if (pending !== null) {
+    result.push(pending);
+  }
+
+  return result;
+}

package/src/client/coalescence/registry.ts

@@ -8,6 +8,9 @@
 import type { Operation } from '../../operations/OperationTypes.js';
 import { coalesceTextInserts, isTextInsertOp, type TextInsertOp } from './textInserts.js';
 import { coalesceTextDeletes, isTextDeleteOp, type TextDeleteOp } from './textDeletes.js';
+import { coalesceNumberAdds, isNumberAddOp } from './numberOperations.js';
+import { coalesceVector3Adds, isVector3AddOp } from './vector3Operations.js';
+import { coalesceLWWSets, isLWWSetOp } from './lwwOperations.js';
 
 export interface CoalesceOptions {
   /** Time threshold in milliseconds (default: 1000ms = 1 second) */
@@ -135,3 +138,22 @@ export function coalesceOperations(
 // Register built-in coalescers
 registerCoalescer('text.insert', isTextInsertOp as TypeGuard<any>, coalesceTextInserts as CoalesceHandler<any>);
 registerCoalescer('text.delete', isTextDeleteOp as TypeGuard<any>, coalesceTextDeletes as CoalesceHandler<any>);
+registerCoalescer('number.add', isNumberAddOp as TypeGuard<any>, coalesceNumberAdds as CoalesceHandler<any>);
+registerCoalescer('vector3.add', isVector3AddOp as TypeGuard<any>, coalesceVector3Adds as CoalesceHandler<any>);
+
+// Register LWW coalescer for all *.set operations
+const LWW_SET_OPERATIONS = [
+  'number.set',
+  'string.set',
+  'boolean.set',
+  'vector3.set',
+  'euler.set',
+  'quaternion.set',
+  'color.set',
+  'array.set',
+  'object.set',
+] as const;
+
+for (const otype of LWW_SET_OPERATIONS) {
+  registerCoalescer(otype, isLWWSetOp as TypeGuard<any>, coalesceLWWSets as CoalesceHandler<any>);
+}

package/src/client/coalescence/vector3Operations.ts

@@ -0,0 +1,85 @@
+/**
+ * Vector3 Operations Coalescence
+ *
+ * Merges consecutive vector3.add operations on the same target.
+ * Component-wise addition is commutative, so we can safely merge multiple adds.
+ */
+
+import type { Operation, Vector3AddOp } from '../../operations/OperationTypes.js';
+import type { CoalesceOptions } from './registry.js';
+
+// Re-export type for convenience
+export type { Vector3AddOp };
+
+/**
+ * Check if an operation is a vector3.add operation
+ */
+export function isVector3AddOp(op: Operation): op is Vector3AddOp {
+  return (
+    op.otype === 'vector3.add' &&
+    Array.isArray((op as any).value) &&
+    (op as any).value.length === 3
+  );
+}
+
+/**
+ * Coalesce consecutive vector3.add operations.
+ *
+ * Since component-wise addition is commutative, we can safely merge
+ * all consecutive adds into a single operation by summing the vectors.
+ *
+ * Example:
+ * Input:  [add(key:"player", path:"position", value:[1,0,0]), add(key:"player", path:"position", value:[0,2,0])]
+ * Output: [add(key:"player", path:"position", value:[1,2,0])]
+ *
+ * @param ops - Array of vector3.add operations
+ * @param options - Coalescence options
+ *   NOTE: Time threshold is ignored for commutative operations like vector addition.
+ *   Component-wise addition is commutative regardless of timing, so we merge
+ *   all consecutive operations on the same target without time restrictions.
+ * @returns New array with coalesced operations
+ */
+export function coalesceVector3Adds(
+  ops: Vector3AddOp[],
+  options: CoalesceOptions = {}
+): Vector3AddOp[] {
+  if (ops.length === 0) return ops;
+
+  const result: Vector3AddOp[] = [];
+  let pending: Vector3AddOp | null = null;
+
+  for (const op of ops) {
+    if (pending === null) {
+      // Start new pending add (copy value array to avoid mutations)
+      pending = { ...op, value: [...op.value] as [number, number, number] };
+    } else {
+      // Check if operations target the same property
+      const sameTarget = pending.key === op.key && pending.path === op.path;
+
+      if (sameTarget) {
+        // Merge operations by summing vectors component-wise
+        pending = {
+          otype: 'vector3.add',
+          key: pending.key,
+          path: pending.path,
+          value: [
+            pending.value[0] + op.value[0],
+            pending.value[1] + op.value[1],
+            pending.value[2] + op.value[2],
+          ],
+        };
+      } else {
+        // Different target - flush pending and start new
+        result.push(pending);
+        pending = { ...op, value: [...op.value] as [number, number, number] };
+      }
+    }
+  }
+
+  // Flush any remaining pending add
+  if (pending !== null) {
+    result.push(pending);
+  }
+
+  return result;
+}

package/tests/client/graph-coalescence-phase1.test.ts

@@ -0,0 +1,357 @@
+/**
+ * Phase 1 Graph Operation Coalescence Tests
+ *
+ * Integration tests for:
+ * - number.add coalescence
+ * - vector3.add coalescence
+ * - LWW (*.set) coalescence
+ *
+ * Tests the full pipeline: GraphStore.edit → commit → coalescence → onSend
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+import { createGraph } from '../../src/client/createGraph.js';
+import type { CRDTMessage } from '../../src/operations/OperationTypes.js';
+
+describe('Phase 1 Graph Coalescence', () => {
+  let messages: CRDTMessage[];
+
+  beforeEach(() => {
+    messages = [];
+  });
+
+  describe('number.add coalescence', () => {
+    it('should merge consecutive number.add operations on same target', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      // Create a score counter
+      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0 } });
+      store.commit('create player');
+
+      // Add to score 3 times rapidly
+      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 10 });
+      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 5 });
+      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 3 });
+      store.commit('add to score');
+
+      // Should coalesce into 1 operation with sum: 10 + 5 + 3 = 18
+      const scoreMsg = messages[1];
+      expect(scoreMsg.ops).toHaveLength(1);
+      expect(scoreMsg.ops[0]).toMatchObject({
+        otype: 'number.add',
+        key: 'player',
+        path: 'score',
+        value: 18,
+      });
+    });
+
+    it('should NOT merge number.add operations on different targets', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player1', value: { score: 0 } });
+      store.edit({ otype: 'node.insert', key: 'player2', value: { score: 0 } });
+      store.commit('create players');
+
+      // Add to different players
+      store.edit({ otype: 'number.add', key: 'player1', path: 'score', value: 10 });
+      store.edit({ otype: 'number.add', key: 'player2', path: 'score', value: 5 });
+      store.commit('add to scores');
+
+      // Should NOT coalesce (different keys)
+      const scoreMsg = messages[1];
+      expect(scoreMsg.ops).toHaveLength(2);
+      expect(scoreMsg.ops[0]).toMatchObject({
+        otype: 'number.add',
+        key: 'player1',
+        value: 10,
+      });
+      expect(scoreMsg.ops[1]).toMatchObject({
+        otype: 'number.add',
+        key: 'player2',
+        value: 5,
+      });
+    });
+
+    it('should NOT merge number.add operations on different paths', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0, health: 100 } });
+      store.commit('create player');
+
+      // Add to different properties
+      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 10 });
+      store.edit({ otype: 'number.add', key: 'player', path: 'health', value: -5 });
+      store.commit('update stats');
+
+      // Should NOT coalesce (different paths)
+      const statsMsg = messages[1];
+      expect(statsMsg.ops).toHaveLength(2);
+      expect(statsMsg.ops[0].path).toBe('score');
+      expect(statsMsg.ops[1].path).toBe('health');
+    });
+  });
+
+  describe('vector3.add coalescence', () => {
+    it('should merge consecutive vector3.add operations on same target', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { position: [0, 0, 0] } });
+      store.commit('create player');
+
+      // Move player in multiple steps
+      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [0, 2, 0] });
+      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [0, 0, 3] });
+      store.commit('move player');
+
+      // Should coalesce into 1 operation with sum: [1+0+0, 0+2+0, 0+0+3] = [1, 2, 3]
+      const moveMsg = messages[1];
+      expect(moveMsg.ops).toHaveLength(1);
+      expect(moveMsg.ops[0]).toMatchObject({
+        otype: 'vector3.add',
+        key: 'player',
+        path: 'position',
+        value: [1, 2, 3],
+      });
+    });
+
+    it('should NOT merge vector3.add operations on different targets', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { position: [0, 0, 0], velocity: [0, 0, 0] } });
+      store.commit('create player');
+
+      // Add to different properties
+      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ otype: 'vector3.add', key: 'player', path: 'velocity', value: [0, 1, 0] });
+      store.commit('update player');
+
+      // Should NOT coalesce (different paths)
+      const updateMsg = messages[1];
+      expect(updateMsg.ops).toHaveLength(2);
+      expect(updateMsg.ops[0].path).toBe('position');
+      expect(updateMsg.ops[1].path).toBe('velocity');
+    });
+  });
+
+  describe('LWW (*.set) coalescence', () => {
+    it('should keep only last number.set operation on same target', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0 } });
+      store.commit('create player');
+
+      // Set score multiple times
+      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 10 });
+      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 20 });
+      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 30 });
+      store.commit('set score');
+
+      // Should keep only last set (LWW)
+      const scoreMsg = messages[1];
+      expect(scoreMsg.ops).toHaveLength(1);
+      expect(scoreMsg.ops[0]).toMatchObject({
+        otype: 'number.set',
+        key: 'player',
+        path: 'score',
+        value: 30, // Only last value
+      });
+    });
+
+    it('should keep only last string.set operation on same target', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { name: '' } });
+      store.commit('create player');
+
+      // Set name multiple times
+      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Alice' });
+      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Bob' });
+      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Charlie' });
+      store.commit('set name');
+
+      // Should keep only last set (LWW)
+      const nameMsg = messages[1];
+      expect(nameMsg.ops).toHaveLength(1);
+      expect(nameMsg.ops[0]).toMatchObject({
+        otype: 'string.set',
+        key: 'player',
+        path: 'name',
+        value: 'Charlie', // Only last value
+      });
+    });
+
+    it('should keep only last boolean.set operation on same target', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { active: false } });
+      store.commit('create player');
+
+      // Toggle active multiple times
+      store.edit({ otype: 'boolean.set', key: 'player', path: 'active', value: true });
+      store.edit({ otype: 'boolean.set', key: 'player', path: 'active', value: false });
+      store.edit({ otype: 'boolean.set', key: 'player', path: 'active', value: true });
+      store.commit('toggle active');
+
+      // Should keep only last set (LWW)
+      const activeMsg = messages[1];
+      expect(activeMsg.ops).toHaveLength(1);
+      expect(activeMsg.ops[0]).toMatchObject({
+        otype: 'boolean.set',
+        key: 'player',
+        path: 'active',
+        value: true, // Only last value
+      });
+    });
+
+    it('should keep only last vector3.set operation on same target', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { position: [0, 0, 0] } });
+      store.commit('create player');
+
+      // Set position multiple times
+      store.edit({ otype: 'vector3.set', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ otype: 'vector3.set', key: 'player', path: 'position', value: [2, 0, 0] });
+      store.edit({ otype: 'vector3.set', key: 'player', path: 'position', value: [3, 0, 0] });
+      store.commit('set position');
+
+      // Should keep only last set (LWW)
+      const posMsg = messages[1];
+      expect(posMsg.ops).toHaveLength(1);
+      expect(posMsg.ops[0]).toMatchObject({
+        otype: 'vector3.set',
+        key: 'player',
+        path: 'position',
+        value: [3, 0, 0], // Only last value
+      });
+    });
+
+    it('should NOT merge set operations on different paths', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0, health: 100 } });
+      store.commit('create player');
+
+      // Set different properties
+      store.edit({ otype: 'number.set', key: 'player', path: 'score', value: 10 });
+      store.edit({ otype: 'number.set', key: 'player', path: 'health', value: 50 });
+      store.commit('set stats');
+
+      // Should NOT coalesce (different paths)
+      const statsMsg = messages[1];
+      expect(statsMsg.ops).toHaveLength(2);
+      expect(statsMsg.ops[0].path).toBe('score');
+      expect(statsMsg.ops[1].path).toBe('health');
+    });
+  });
+
+  describe('Mixed operations', () => {
+    it('should coalesce operations independently by type', () => {
+      const store = createGraph({
+        sessionId: 'alice',
+        coalescingEnabled: true,
+        coalescingDelayMs: 0,
+        coalescingThresholdMs: 1000,
+        onSend: (msg) => messages.push(msg),
+      });
+
+      store.edit({ otype: 'node.insert', key: 'player', value: { score: 0, position: [0, 0, 0], name: '' } });
+      store.commit('create player');
+
+      // Mix of operations
+      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 10 });
+      store.edit({ otype: 'number.add', key: 'player', path: 'score', value: 5 });
+      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [1, 0, 0] });
+      store.edit({ otype: 'vector3.add', key: 'player', path: 'position', value: [0, 2, 0] });
+      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Alice' });
+      store.edit({ otype: 'string.set', key: 'player', path: 'name', value: 'Bob' });
+      store.commit('update player');
+
+      // Should coalesce each type independently
+      const updateMsg = messages[1];
+      expect(updateMsg.ops).toHaveLength(3); // 1 number.add, 1 vector3.add, 1 string.set
+
+      // number.add should be coalesced: 10 + 5 = 15
+      expect(updateMsg.ops[0]).toMatchObject({
+        otype: 'number.add',
+        path: 'score',
+        value: 15,
+      });
+
+      // vector3.add should be coalesced: [1, 0, 0] + [0, 2, 0] = [1, 2, 0]
+      expect(updateMsg.ops[1]).toMatchObject({
+        otype: 'vector3.add',
+        path: 'position',
+        value: [1, 2, 0],
+      });
+
+      // string.set should keep last: 'Bob'
+      expect(updateMsg.ops[2]).toMatchObject({
+        otype: 'string.set',
+        path: 'name',
+        value: 'Bob',
+      });
+    });
+  });
+});