@dabble/patches 0.8.1 → 0.8.3

package/dist/algorithms/ot/shared/rebaseChanges.js

@@ -20,12 +20,13 @@ function rebaseChanges(serverChanges, localChanges) {
   );
   const baseRev = lastChange.rev;
   let rev = lastChange.rev;
-  const result = filteredLocalChanges.map((change) => {
-    rev++;
+  const result = [];
+  for (const change of filteredLocalChanges) {
     const ops = transformPatch.transform(change.ops).ops;
-    if (!ops.length) return null;
-    return { ...change, baseRev, rev, ops };
-  }).filter(Boolean);
+    if (!ops.length) continue;
+    rev++;
+    result.push({ ...change, baseRev, rev, ops });
+  }
   return result;
 }
 export {

package/dist/client/LWWDoc.js

@@ -17,13 +17,8 @@ class LWWDoc extends BaseDoc {
     this._committedRev = snapshot?.rev ?? 0;
     this._hasPending = (snapshot?.changes?.length ?? 0) > 0;
     if (snapshot?.changes && snapshot.changes.length > 0) {
-      let currentState = this.state;
-      for (const change of snapshot.changes) {
-        for (const op of change.ops) {
-          currentState = applyPatch(currentState, [op], { partial: true });
-        }
-      }
-      this.state = currentState;
+      const allOps = snapshot.changes.flatMap((c) => c.ops);
+      this.state = applyPatch(this.state, allOps, { partial: true });
     }
     this._baseState = this.state;
     this._checkLoaded();
@@ -46,11 +41,11 @@ class LWWDoc extends BaseDoc {
     this._optimisticOps = [];
     let currentState = snapshot.state;
     if (snapshot.changes && snapshot.changes.length > 0) {
-      for (const change of snapshot.changes) {
-        for (const op of change.ops) {
-          currentState = applyPatch(currentState, [op], { partial: true });
-        }
-      }
+      currentState = applyPatch(
+        currentState,
+        snapshot.changes.flatMap((c) => c.ops),
+        { partial: true }
+      );
     }
     this._baseState = currentState;
     this._checkLoaded();
@@ -97,20 +92,12 @@ class LWWDoc extends BaseDoc {
     this._hasPending = hasPending ?? hasPendingChanges;
     this._checkLoaded();
     if (hasServerChanges) {
-      let newBaseState = this._baseState;
-      for (const change of changes) {
-        for (const op of change.ops) {
-          newBaseState = applyPatch(newBaseState, [op], { partial: true });
-        }
-      }
-      this._baseState = newBaseState;
+      const allOps = changes.flatMap((c) => c.ops);
+      this._baseState = applyPatch(this._baseState, allOps, { partial: true });
       this._recomputeState();
     } else {
-      for (const change of changes) {
-        for (const op of change.ops) {
-          this._baseState = applyPatch(this._baseState, [op], { partial: true });
-        }
-      }
+      const allOps = changes.flatMap((c) => c.ops);
+      this._baseState = applyPatch(this._baseState, allOps, { partial: true });
       if (this._optimisticOps.length > 0) {
         this._optimisticOps.shift();
       } else {

package/dist/client/Patches.js

@@ -102,8 +102,6 @@ class Patches {
     if (!docIds.length) return;
     docIds.forEach(this.trackedDocs.delete, this.trackedDocs);
     this.onUntrackDocs.emit(docIds);
-    const closedPromises = docIds.filter((id) => this.docs.has(id)).map((id) => this.closeDoc(id));
-    await Promise.all(closedPromises);
     const byAlgorithm = /* @__PURE__ */ new Map();
     for (const docId of docIds) {
       const managed = this.docs.get(docId);
@@ -112,6 +110,8 @@ class Patches {
       list.push(docId);
       byAlgorithm.set(algorithm, list);
     }
+    const closedPromises = docIds.filter((id) => this.docs.has(id)).map((id) => this.closeDoc(id));
+    await Promise.all(closedPromises);
     await Promise.all([...byAlgorithm.entries()].map(([algorithm, ids]) => algorithm.untrackDocs(ids)));
   }
   // ensure a second call to openDoc with the same docId returns the same promise while opening

package/dist/client/PatchesDoc.d.ts

@@ -1,6 +1,6 @@
 import 'easy-signal';
 import '../json-patch/types.js';
 import '../types.js';
-export { O as OTDoc, P as PatchesDoc, O as PatchesDocClass, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
+export { O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/PatchesDoc.js

@@ -1,6 +1,5 @@
 import "../chunk-IZ2YBCUP.js";
-import { OTDoc, OTDoc as OTDoc2 } from "./OTDoc.js";
+import { OTDoc } from "./OTDoc.js";
 export {
-  OTDoc,
-  OTDoc2 as PatchesDocClass
+  OTDoc
 };

package/dist/client/index.d.ts

@@ -1,4 +1,4 @@
-export { B as BaseDoc, O as OTDoc, P as PatchesDoc, O as PatchesDocClass, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
+export { B as BaseDoc, O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from '../BaseDoc-BT18xPxU.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './IndexedDBStore.js';
 export { OTIndexedDBStore } from './OTIndexedDBStore.js';

package/dist/{index-C7ZhU2kS.d.ts → index-BO6EQFpw.d.ts}

@@ -1,4 +1,4 @@
-import { JSONPatchOpHandlerMap, JSONPatchOpHandler } from './json-patch/types.js';
+import { JSONPatchOpHandlerMap } from './json-patch/types.js';
 import { add } from './json-patch/ops/add.js';
 import { bit } from './json-patch/ops/bitmask.js';
 import { copy } from './json-patch/ops/copy.js';
@@ -9,19 +9,7 @@ import { remove } from './json-patch/ops/remove.js';
 import { replace } from './json-patch/ops/replace.js';
 import { test } from './json-patch/ops/test.js';
 
-declare function getTypes(custom?: JSONPatchOpHandlerMap): {
-    test: JSONPatchOpHandler;
-    add: JSONPatchOpHandler;
-    remove: JSONPatchOpHandler;
-    replace: JSONPatchOpHandler;
-    copy: JSONPatchOpHandler;
-    move: JSONPatchOpHandler;
-    '@inc': JSONPatchOpHandler;
-    '@bit': JSONPatchOpHandler;
-    '@txt': JSONPatchOpHandler;
-    '@max': JSONPatchOpHandler;
-    '@min': JSONPatchOpHandler;
-};
+declare function getTypes(custom?: JSONPatchOpHandlerMap): JSONPatchOpHandlerMap;
 
 declare const index_add: typeof add;
 declare const index_bit: typeof bit;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Delta } from '@dabble/delta';
-export { B as BaseDoc, O as OTDoc, P as PatchesDoc, O as PatchesDocClass, a as PatchesDocOptions } from './BaseDoc-BT18xPxU.js';
+export { B as BaseDoc, O as OTDoc, P as PatchesDoc, a as PatchesDocOptions } from './BaseDoc-BT18xPxU.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './client/factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
 export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';
@@ -18,25 +18,25 @@ export { LWWClientStore } from './client/LWWClientStore.js';
 export { ClientAlgorithm } from './client/ClientAlgorithm.js';
 export { createChange } from './data/change.js';
 export { createVersionId, createVersionMetadata } from './data/version.js';
-export { ReadonlyStore, Signal, SignalSubscriber, Store, Subscriber, Unsubscriber, afterChange, batch, clearAllContext, computed, readonly, signal, store, watch, whenMatches, whenReady } from 'easy-signal';
+export { ReadonlyStore, Signal, SignalSubscriber, Store, Subscriber, Unsubscriber, batch, computed, readonly, signal, store, watch } from 'easy-signal';
 export { fractionalIndex, healDuplicateOrders, sortByOrder } from './fractionalIndex.js';
 export { applyPatch } from './json-patch/applyPatch.js';
 export { composePatch } from './json-patch/composePatch.js';
 export { invertPatch } from './json-patch/invertPatch.js';
-export { applyBitmask, bit, bitmask, combineBitmasks } from './json-patch/ops/bitmask.js';
-export { i as defaultOps, g as getTypes } from './index-C7ZhU2kS.js';
+export { applyBitmask, bitmask, combineBitmasks } from './json-patch/ops/bitmask.js';
+export { i as defaultOps } from './index-BO6EQFpw.js';
 export { createPathProxy, pathProxy } from './json-patch/pathProxy.js';
 export { transformPatch } from './json-patch/transformPatch.js';
 export { JSONPatch, PathLike, WriteOptions } from './json-patch/JSONPatch.js';
-export { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './json-patch/types.js';
+export { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandlerMap } from './json-patch/types.js';
 export { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocSyncState, DocSyncStatus, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, VersionMetadata } from './types.js';
-export { add } from './json-patch/ops/add.js';
-export { copy } from './json-patch/ops/copy.js';
-export { increment } from './json-patch/ops/increment.js';
-export { max, min } from './json-patch/ops/minmax.js';
-export { move } from './json-patch/ops/move.js';
-export { remove } from './json-patch/ops/remove.js';
-export { replace } from './json-patch/ops/replace.js';
-export { test } from './json-patch/ops/test.js';
 import './utils/deferred.js';
 import './net/protocol/types.js';
+import './json-patch/ops/add.js';
+import './json-patch/ops/copy.js';
+import './json-patch/ops/increment.js';
+import './json-patch/ops/minmax.js';
+import './json-patch/ops/move.js';
+import './json-patch/ops/remove.js';
+import './json-patch/ops/replace.js';
+import './json-patch/ops/test.js';

package/dist/index.js

@@ -9,24 +9,16 @@ import {
   readonly,
   computed,
   batch,
-  watch,
-  whenReady,
-  whenMatches,
-  afterChange,
-  clearAllContext
+  watch
 } from "easy-signal";
 export * from "./fractionalIndex.js";
 export * from "./json-patch/index.js";
 export {
   Delta,
-  afterChange,
   batch,
-  clearAllContext,
   computed,
   readonly,
   signal,
   store,
-  watch,
-  whenMatches,
-  whenReady
+  watch
 };

package/dist/json-patch/index.d.ts

@@ -1,19 +1,19 @@
 export { applyPatch } from './applyPatch.js';
 export { composePatch } from './composePatch.js';
 export { invertPatch } from './invertPatch.js';
-export { applyBitmask, bit, bitmask, combineBitmasks } from './ops/bitmask.js';
-export { i as defaultOps, g as getTypes } from '../index-C7ZhU2kS.js';
+export { applyBitmask, bitmask, combineBitmasks } from './ops/bitmask.js';
+export { i as defaultOps } from '../index-BO6EQFpw.js';
 export { createPathProxy, pathProxy } from './pathProxy.js';
 export { transformPatch } from './transformPatch.js';
 export { JSONPatch, PathLike, WriteOptions } from './JSONPatch.js';
-export { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './types.js';
-export { add } from './ops/add.js';
-export { copy } from './ops/copy.js';
-export { increment } from './ops/increment.js';
-export { max, min } from './ops/minmax.js';
-export { move } from './ops/move.js';
-export { remove } from './ops/remove.js';
-export { replace } from './ops/replace.js';
-export { test } from './ops/test.js';
+export { ApplyJSONPatchOptions, JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+import './ops/add.js';
+import './ops/copy.js';
+import './ops/increment.js';
+import './ops/minmax.js';
+import './ops/move.js';
+import './ops/remove.js';
+import './ops/replace.js';
+import './ops/test.js';
 import '../types.js';
 import '@dabble/delta';

package/dist/json-patch/index.js

@@ -7,7 +7,6 @@ import * as defaultOps from "./ops/index.js";
 export * from "./pathProxy.js";
 import { transformPatch } from "./transformPatch.js";
 export * from "./JSONPatch.js";
-export * from "./ops/index.js";
 export {
   applyBitmask,
   applyPatch,

package/dist/json-patch/ops/index.d.ts

@@ -8,4 +8,4 @@ export { move } from './move.js';
 export { remove } from './remove.js';
 export { replace } from './replace.js';
 export { test } from './test.js';
-export { g as getTypes } from '../../index-C7ZhU2kS.js';
+export { g as getTypes } from '../../index-BO6EQFpw.js';

package/dist/json-patch/ops/index.js

@@ -9,21 +9,22 @@ import { remove } from "./remove.js";
 import { replace } from "./replace.js";
 import { test } from "./test.js";
 import { text } from "./text.js";
+const defaultTypes = {
+  test,
+  add,
+  remove,
+  replace,
+  copy,
+  move,
+  "@inc": increment,
+  "@bit": bit,
+  "@txt": text,
+  "@max": max,
+  "@min": min
+};
 function getTypes(custom) {
-  return {
-    test,
-    add,
-    remove,
-    replace,
-    copy,
-    move,
-    "@inc": increment,
-    "@bit": bit,
-    "@txt": text,
-    "@max": max,
-    "@min": min,
-    ...custom
-  };
+  if (!custom || Object.keys(custom).length === 0) return defaultTypes;
+  return { ...defaultTypes, ...custom };
 }
 export {
   add,

package/dist/micro/client.js

@@ -1,6 +1,7 @@
 import "../chunk-IZ2YBCUP.js";
 import { signal } from "easy-signal";
 import { MicroDoc } from "./doc.js";
+import { transformPendingTxt } from "./ops.js";
 class MicroClient {
   _url;
   _dbName;
@@ -29,10 +30,27 @@ class MicroClient {
       }
     }
     try {
-      const remote = await this._fetch(`/docs/${docId}`);
-      if (remote.rev > state.rev) {
-        state = remote;
-        pending = {};
+      if (state.rev > 0 && Object.keys(pending).length) {
+        try {
+          const sync = await this._fetch(`/docs/${docId}/sync?since=${state.rev}`);
+          if (sync.rev > state.rev) {
+            Object.assign(state.fields, sync.fields);
+            pending = transformPendingTxt(pending, sync.textLog);
+            state.rev = sync.rev;
+          }
+        } catch {
+          const remote = await this._fetch(`/docs/${docId}`);
+          if (remote.rev > state.rev) {
+            state = remote;
+            pending = {};
+          }
+        }
+      } else {
+        const remote = await this._fetch(`/docs/${docId}`);
+        if (remote.rev > state.rev) {
+          state = remote;
+          pending = {};
+        }
       }
     } catch {
     }
@@ -64,10 +82,10 @@ class MicroClient {
   }
   /** Disconnect WebSocket and clean up. */
   destroy() {
-    for (const [id, entry] of this._docs) {
+    for (const entry of this._docs.values()) {
       if (entry.timer) clearTimeout(entry.timer);
-      this._docs.delete(id);
     }
+    this._docs.clear();
     if (this._wsTimer) clearTimeout(this._wsTimer);
     this._ws?.close();
     this._ws = null;

package/dist/micro/doc.js

@@ -2,16 +2,16 @@ import "../chunk-IZ2YBCUP.js";
 import { Delta } from "@dabble/delta";
 import { batch, store } from "easy-signal";
 import { buildState, consolidateOps, effectiveFields, generateId, mergeField } from "./ops.js";
-import { TXT, parseSuffix } from "./types.js";
+import {} from "./types.js";
 function createUpdater(emit, path = "") {
   return new Proxy({}, {
     get(_, prop) {
       const p = path ? `${path}.${prop}` : prop;
       switch (prop) {
         case "set":
-          return (val) => emit(path, "", val);
+          return (val) => emit(path, "=", val);
         case "del":
-          return () => emit(path, "", null);
+          return () => emit(path, "!", null);
         case "inc":
           return (val = 1) => emit(path, "+", val);
         case "bit":
@@ -59,8 +59,8 @@ class MicroDoc {
   update(fn) {
     const ops = {};
     const ts = Date.now();
-    const emit = (path, suffix, val) => {
-      ops[suffix ? path + suffix : path] = { val, ts };
+    const emit = (path, op, val) => {
+      ops[path] = { op, val, ts };
     };
     fn(createUpdater(emit));
     if (!Object.keys(ops).length) return;
@@ -80,12 +80,11 @@ class MicroDoc {
   _confirmSend(rev) {
     if (!this._sending) return;
     for (const [key, field] of Object.entries(this._sending)) {
-      const { suffix } = parseSuffix(key);
-      if (suffix === TXT) {
+      if (field.op === "#") {
         const base = this._confirmed[key]?.val ? new Delta(this._confirmed[key].val) : new Delta();
-        this._confirmed[key] = { val: base.compose(new Delta(field.val)).ops, ts: field.ts };
+        this._confirmed[key] = { op: "#", val: base.compose(new Delta(field.val)).ops, ts: field.ts };
       } else {
-        this._confirmed[key] = mergeField(this._confirmed[key], field, suffix);
+        this._confirmed[key] = mergeField(this._confirmed[key], field);
       }
     }
     this._sending = null;
@@ -104,23 +103,23 @@ class MicroDoc {
   applyRemote(fields, rev) {
     batch(() => {
       for (const [key, field] of Object.entries(fields)) {
-        const { suffix } = parseSuffix(key);
-        if (suffix === TXT) {
+        if (field.op === "#") {
           const remote = new Delta(field.val);
           if (this._sending?.[key]) {
             const s = new Delta(this._sending[key].val);
-            this._sending[key] = { val: s.transform(remote, false).ops, ts: this._sending[key].ts };
-            const rPrime = remote.transform(s, true);
+            const sPrime = remote.transform(s, true);
+            const rPrime = s.transform(remote, false);
+            this._sending[key] = { op: "#", val: sPrime.ops, ts: this._sending[key].ts };
             if (this._pending[key]) {
               const p = new Delta(this._pending[key].val);
-              this._pending[key] = { val: p.transform(rPrime, false).ops, ts: this._pending[key].ts };
+              this._pending[key] = { op: "#", val: rPrime.transform(p, true).ops, ts: this._pending[key].ts };
             }
           } else if (this._pending[key]) {
             const p = new Delta(this._pending[key].val);
-            this._pending[key] = { val: p.transform(remote, false).ops, ts: this._pending[key].ts };
+            this._pending[key] = { op: "#", val: remote.transform(p, true).ops, ts: this._pending[key].ts };
           }
           const base = this._confirmed[key]?.val ? new Delta(this._confirmed[key].val) : new Delta();
-          this._confirmed[key] = { val: base.compose(remote).ops, ts: field.ts };
+          this._confirmed[key] = { op: "#", val: base.compose(remote).ops, ts: field.ts };
         } else {
           this._confirmed[key] = field;
         }

package/dist/micro/index.d.ts

@@ -1,7 +1,7 @@
 export { ClientOptions, MicroClient } from './client.js';
 export { MicroDoc, Updatable } from './doc.js';
-export { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField } from './ops.js';
+export { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField, transformPendingTxt } from './ops.js';
 export { MemoryDbBackend, MicroServer } from './server.js';
-export { BIT, Change, ChangeLogEntry, CommitResult, DbBackend, DocState, Field, FieldMap, INC, MAX, ObjectStore, REF_THRESHOLD, TXT, TextLogEntry, parseSuffix } from './types.js';
+export { Change, ChangeLogEntry, CommitResult, CommitWrite, DbBackend, DocState, Field, FieldMap, ObjectStore, Op, REF_THRESHOLD, RevConflictError, SyncResult, TextLogEntry } from './types.js';
 import 'easy-signal';
 import '@dabble/delta';

package/dist/micro/index.js

@@ -1,19 +1,26 @@
 import "../chunk-IZ2YBCUP.js";
 import { MicroClient } from "./client.js";
 import { MicroDoc } from "./doc.js";
-import { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField } from "./ops.js";
+import {
+  applyBitmask,
+  bitmask,
+  buildState,
+  combineBitmasks,
+  consolidateOps,
+  effectiveFields,
+  generateId,
+  mergeField,
+  transformPendingTxt
+} from "./ops.js";
 import { MemoryDbBackend, MicroServer } from "./server.js";
-import { BIT, INC, MAX, parseSuffix, REF_THRESHOLD, TXT } from "./types.js";
+import { RevConflictError, REF_THRESHOLD } from "./types.js";
 export {
-  BIT,
-  INC,
-  MAX,
   MemoryDbBackend,
   MicroClient,
   MicroDoc,
   MicroServer,
   REF_THRESHOLD,
-  TXT,
+  RevConflictError,
   applyBitmask,
   bitmask,
   buildState,
@@ -22,5 +29,5 @@ export {
   effectiveFields,
   generateId,
   mergeField,
-  parseSuffix
+  transformPendingTxt
 };

package/dist/micro/ops.d.ts

@@ -8,13 +8,15 @@ declare function applyBitmask(num: number, mask: number): number;
 declare function combineBitmasks(a: number, b: number): number;
 /** Generate a random ID. */
 declare function generateId(): string;
-/** Merge a single incoming field with an existing value, based on suffix type. */
-declare function mergeField(existing: Field | undefined, incoming: Field, suffix: string): Field;
+/** Merge a single incoming field with an existing value, based on op type. */
+declare function mergeField(existing: Field | undefined, incoming: Field): Field;
 /** Consolidate new ops into existing pending ops (client-side batching). */
 declare function consolidateOps(pending: FieldMap, newOps: FieldMap): FieldMap;
-/** Convert flat dot-notation FieldMap to a nested object. Strips suffixes from keys. */
+/** Transform pending TXT field deltas against server text log entries (for reconnection). */
+declare function transformPendingTxt(pending: FieldMap, textLog: Record<string, any[]>): FieldMap;
+/** Convert flat dot-notation FieldMap to a nested object. */
 declare function buildState<T = Record<string, any>>(fields: FieldMap): T;
 /** Compute effective fields by layering confirmed + sending + pending. */
 declare function effectiveFields(confirmed: FieldMap, sending: FieldMap | null, pending: FieldMap): FieldMap;
 
-export { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField };
+export { applyBitmask, bitmask, buildState, combineBitmasks, consolidateOps, effectiveFields, generateId, mergeField, transformPendingTxt };

package/dist/micro/ops.js

@@ -1,6 +1,6 @@
 import "../chunk-IZ2YBCUP.js";
 import { Delta } from "@dabble/delta";
-import { BIT, INC, MAX, parseSuffix, TXT } from "./types.js";
+import {} from "./types.js";
 function bitmask(index, value) {
   if (index < 0 || index > 14) throw new Error("Index must be between 0 and 14");
   return value ? 1 << index : 1 << index + 15;
@@ -16,16 +16,16 @@ function combineBitmasks(a, b) {
 function generateId() {
   return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
 }
-function mergeField(existing, incoming, suffix) {
+function mergeField(existing, incoming) {
   const ev = existing?.val ?? 0;
-  switch (suffix) {
-    case INC:
-      return { val: ev + incoming.val, ts: incoming.ts };
-    case BIT:
-      return { val: applyBitmask(ev, incoming.val), ts: incoming.ts };
-    case MAX:
+  switch (incoming.op) {
+    case "+":
+      return { op: "+", val: ev + incoming.val, ts: incoming.ts };
+    case "~":
+      return { op: "~", val: applyBitmask(ev, incoming.val), ts: incoming.ts };
+    case "^":
       return incoming.val >= ev ? incoming : existing;
-    case TXT:
+    case "#":
       return incoming;
     // text composed separately
     default:
@@ -40,19 +40,18 @@ function consolidateOps(pending, newOps) {
       result[key] = field;
       continue;
     }
-    const { suffix } = parseSuffix(key);
-    switch (suffix) {
-      case INC:
-        result[key] = { val: ex.val + field.val, ts: field.ts };
+    switch (field.op) {
+      case "+":
+        result[key] = { op: "+", val: ex.val + field.val, ts: field.ts };
         break;
-      case BIT:
-        result[key] = { val: combineBitmasks(ex.val, field.val), ts: field.ts };
+      case "~":
+        result[key] = { op: "~", val: combineBitmasks(ex.val, field.val), ts: field.ts };
         break;
-      case MAX:
+      case "^":
         result[key] = field.val >= ex.val ? field : ex;
         break;
-      case TXT:
-        result[key] = { val: new Delta(ex.val).compose(new Delta(field.val)).ops, ts: field.ts };
+      case "#":
+        result[key] = { op: "#", val: new Delta(ex.val).compose(new Delta(field.val)).ops, ts: field.ts };
         break;
       default:
         result[key] = field;
@@ -60,12 +59,23 @@ function consolidateOps(pending, newOps) {
   }
   return result;
 }
+function transformPendingTxt(pending, textLog) {
+  const result = { ...pending };
+  for (const [key, deltas] of Object.entries(textLog)) {
+    if (!result[key]) continue;
+    let p = new Delta(result[key].val);
+    for (const delta of deltas) {
+      p = new Delta(delta).transform(p, true);
+    }
+    result[key] = { op: "#", val: p.ops, ts: result[key].ts };
+  }
+  return result;
+}
 function buildState(fields) {
   const obj = {};
   for (const [key, field] of Object.entries(fields)) {
     if (field.val == null) continue;
-    const { path } = parseSuffix(key);
-    const parts = path.split(".");
+    const parts = key.split(".");
     let cur = obj;
     for (let i = 0; i < parts.length - 1; i++) cur = cur[parts[i]] ??= {};
     cur[parts[parts.length - 1]] = field.val;
@@ -77,12 +87,11 @@ function effectiveFields(confirmed, sending, pending) {
   const layers = sending ? [sending, pending] : [pending];
   for (const layer of layers) {
     for (const [key, field] of Object.entries(layer)) {
-      const { suffix } = parseSuffix(key);
-      if (suffix === TXT) {
+      if (field.op === "#") {
         const base = result[key]?.val ? new Delta(result[key].val) : new Delta();
-        result[key] = { val: base.compose(new Delta(field.val)).ops, ts: field.ts };
+        result[key] = { op: "#", val: base.compose(new Delta(field.val)).ops, ts: field.ts };
       } else {
-        result[key] = mergeField(result[key], field, suffix);
+        result[key] = mergeField(result[key], field);
       }
     }
   }
@@ -96,5 +105,6 @@ export {
   consolidateOps,
   effectiveFields,
   generateId,
-  mergeField
+  mergeField,
+  transformPendingTxt
 };