@dabble/patches 0.5.22 → 0.7.0

package/dist/client/factories.js

@@ -0,0 +1,80 @@
+import "../chunk-IZ2YBCUP.js";
+import { InMemoryStore } from "./InMemoryStore.js";
+import { LWWInMemoryStore } from "./LWWInMemoryStore.js";
+import { LWWIndexedDBStore } from "./LWWIndexedDBStore.js";
+import { LWWAlgorithm } from "./LWWAlgorithm.js";
+import { OTIndexedDBStore } from "./OTIndexedDBStore.js";
+import { OTAlgorithm } from "./OTAlgorithm.js";
+import { Patches } from "./Patches.js";
+function createOTPatches(options = {}) {
+  const store = new InMemoryStore();
+  const otAlgorithm = new OTAlgorithm(store, options.docOptions);
+  return new Patches({
+    algorithms: { ot: otAlgorithm },
+    defaultAlgorithm: "ot",
+    metadata: options.metadata,
+    docOptions: options.docOptions
+  });
+}
+function createOTIndexedDBPatches(options) {
+  const store = new OTIndexedDBStore(options.dbName);
+  const otAlgorithm = new OTAlgorithm(store, options.docOptions);
+  return new Patches({
+    algorithms: { ot: otAlgorithm },
+    defaultAlgorithm: "ot",
+    metadata: options.metadata,
+    docOptions: options.docOptions
+  });
+}
+function createLWWPatches(options = {}) {
+  const store = new LWWInMemoryStore();
+  const lwwAlgorithm = new LWWAlgorithm(store);
+  return new Patches({
+    algorithms: { lww: lwwAlgorithm },
+    defaultAlgorithm: "lww",
+    metadata: options.metadata,
+    docOptions: options.docOptions
+  });
+}
+function createLWWIndexedDBPatches(options) {
+  const store = new LWWIndexedDBStore(options.dbName);
+  const lwwAlgorithm = new LWWAlgorithm(store);
+  return new Patches({
+    algorithms: { lww: lwwAlgorithm },
+    defaultAlgorithm: "lww",
+    metadata: options.metadata,
+    docOptions: options.docOptions
+  });
+}
+function createAllPatches(options = {}) {
+  const otStore = new InMemoryStore();
+  const lwwStore = new LWWInMemoryStore();
+  const otAlgorithm = new OTAlgorithm(otStore, options.docOptions);
+  const lwwAlgorithm = new LWWAlgorithm(lwwStore);
+  return new Patches({
+    algorithms: { ot: otAlgorithm, lww: lwwAlgorithm },
+    defaultAlgorithm: options.defaultAlgorithm ?? "ot",
+    metadata: options.metadata,
+    docOptions: options.docOptions
+  });
+}
+function createAllIndexedDBPatches(options) {
+  const otStore = new OTIndexedDBStore(options.dbName);
+  const lwwStore = new LWWIndexedDBStore(`${options.dbName}-lww`);
+  const otAlgorithm = new OTAlgorithm(otStore, options.docOptions);
+  const lwwAlgorithm = new LWWAlgorithm(lwwStore);
+  return new Patches({
+    algorithms: { ot: otAlgorithm, lww: lwwAlgorithm },
+    defaultAlgorithm: options.defaultAlgorithm ?? "ot",
+    metadata: options.metadata,
+    docOptions: options.docOptions
+  });
+}
+export {
+  createAllIndexedDBPatches,
+  createAllPatches,
+  createLWWIndexedDBPatches,
+  createLWWPatches,
+  createOTIndexedDBPatches,
+  createOTPatches
+};

package/dist/client/index.d.ts

@@ -1,14 +1,23 @@
-export { IndexedDBStore } from './IndexedDBStore.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-DkP3tUhT.js';
+export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createAllIndexedDBPatches, createAllPatches, createLWWIndexedDBPatches, createLWWPatches, createOTIndexedDBPatches, createOTPatches } from './factories.js';
+export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './IndexedDBStore.js';
+export { OTIndexedDBStore } from './OTIndexedDBStore.js';
+export { LWWIndexedDBStore } from './LWWIndexedDBStore.js';
 export { InMemoryStore } from './InMemoryStore.js';
+export { LWWInMemoryStore } from './LWWInMemoryStore.js';
+export { LWWDoc } from './LWWDoc.js';
+export { LWWAlgorithm } from './LWWAlgorithm.js';
+export { OTAlgorithm } from './OTAlgorithm.js';
 export { Patches, PatchesOptions } from './Patches.js';
-export { PatchesDoc, PatchesDocOptions } from './PatchesDoc.js';
 export { PatchesHistoryClient } from './PatchesHistoryClient.js';
 export { PatchesStore, TrackedDoc } from './PatchesStore.js';
+export { OTClientStore } from './OTClientStore.js';
+export { LWWClientStore } from './LWWClientStore.js';
+export { AlgorithmName, ClientAlgorithm } from './ClientAlgorithm.js';
+import '../event-signal.js';
+import '../json-patch/types.js';
 import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../json-patch/types.js';
 import '../utils/deferred.js';
-import '../event-signal.js';
-import '../algorithms/shared/changeBatching.js';
 import '../net/protocol/types.js';

package/dist/client/index.js

@@ -1,5 +1,14 @@
+export * from "./BaseDoc.js";
+export * from "./factories.js";
 export * from "./IndexedDBStore.js";
+export * from "./OTIndexedDBStore.js";
+export * from "./LWWIndexedDBStore.js";
 export * from "./InMemoryStore.js";
+export * from "./LWWInMemoryStore.js";
+export * from "./LWWDoc.js";
+export * from "./LWWAlgorithm.js";
+export * from "./OTDoc.js";
+export * from "./OTAlgorithm.js";
 export * from "./Patches.js";
 export * from "./PatchesDoc.js";
 export * from "./PatchesHistoryClient.js";

package/dist/compression/index.d.ts

@@ -12,7 +12,7 @@ import { JSONPatchOp } from '../json-patch/types.js';
  * ```typescript
  * import { compressedSizeBase64 } from '@dabble/patches/compression';
  *
- * new PatchesDoc(state, {}, {
+ * new OTDoc(state, {}, {
  *   sizeCalculator: compressedSizeBase64,
  *   maxStorageBytes: 1_000_000
  * });

package/dist/data/change.js

@@ -1,7 +1,6 @@
 import "../chunk-IZ2YBCUP.js";
 import { inc } from "alphacounter";
 import { createId } from "crypto-id";
-import { getLocalISO } from "../utils/dates.js";
 function createChangeId(rev) {
   return inc.from(rev) + createId(4);
 }
@@ -10,7 +9,7 @@ function createChange(baseRev, rev, ops, metadata) {
     return {
       id: createId(8),
       ops: baseRev,
-      createdAt: getLocalISO(),
+      createdAt: Date.now(),
       ...rev
     };
   } else {
@@ -19,7 +18,9 @@ function createChange(baseRev, rev, ops, metadata) {
       baseRev,
       rev,
       ops,
-      createdAt: getLocalISO(),
+      createdAt: Date.now(),
+      committedAt: 0,
+      // Set to 0 for uncommitted changes; server sets actual timestamp on commit
       ...metadata
     };
   }

package/dist/fractionalIndex.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Generate a fractional index which is a sortable string(s) between a and b. Use an empty string or null/undefined to
+ * represent the start and end of the range.
+ *
+ * Pass a count to generate N fractional indexes between a and b.
+ *
+ * See https://www.figma.com/blog/realtime-editing-of-ordered-sequences/#fractional-indexing and
+ * https://observablehq.com/@dgreensp/implementing-fractional-indexing for more information.
+ */
+declare function fractionalIndex(a: string | undefined | null, b: string | undefined | null): string;
+declare function fractionalIndex(a: string | undefined | null, b: string | undefined | null, count: number): string[];
+declare namespace fractionalIndex {
+    var sort: typeof sortByOrder;
+    var heal: typeof healDuplicateOrders;
+}
+/** Order field parameter type: field name, or false when values are order strings directly */
+type OrderFieldParam = string | false;
+/**
+ * Sort a map of items by their fractional index order, with key as tiebreaker.
+ *
+ * @param items - Object keyed by ID. Values can be objects with an order field, or strings (the order itself).
+ * @param orderField - The field name containing the order string (default: 'order'). Use false if values ARE the order strings.
+ * @returns Array of [key, value] tuples sorted by order, then by key
+ *
+ * @example
+ * // Objects with 'order' field (default)
+ * const sorted = sortByOrder({ b: { order: 'a2' }, a: { order: 'a1' } });
+ * // [['a', { order: 'a1' }], ['b', { order: 'a2' }]]
+ *
+ * @example
+ * // Values are the order strings directly
+ * const sorted = sortByOrder({ b: 'a2', a: 'a1' }, false);
+ * // [['a', 'a1'], ['b', 'a2']]
+ */
+declare function sortByOrder<T extends Record<string, unknown> | string>(items: Record<string, T>, orderField?: OrderFieldParam): Array<[string, T]>;
+/**
+ * Detect duplicate `order` values and return fixes. Duplicates can occur when multiple
+ * clients generate the same fractional index while offline (e.g., both appending to a list).
+ *
+ * This function does NOT mutate the input. Apply the returned fixes using your change API.
+ *
+ * @param items - Object keyed by ID. Values can be objects with an order field, or strings (the order itself).
+ * @param orderField - The field name containing the order string (default: 'order'). Use false if values ARE the order strings.
+ * @returns Map of key → new order string, or null if no duplicates found
+ *
+ * @example
+ * // Objects with 'order' field (default)
+ * const fixes = healDuplicateOrders({ a: { order: 'a1' }, b: { order: 'a1' } });
+ * if (fixes) {
+ *   doc.change((patch, root) => {
+ *     for (const [key, newOrder] of Object.entries(fixes)) {
+ *       patch.replace(root.items[key].order, newOrder);
+ *     }
+ *   });
+ * }
+ *
+ * @example
+ * // Objects with custom field name
+ * const fixes = healDuplicateOrders({ a: { sortKey: 'a1' } }, 'sortKey');
+ *
+ * @example
+ * // Values are the order strings directly
+ * const fixes = healDuplicateOrders({ a: 'a1', b: 'a1' }, false);
+ */
+declare function healDuplicateOrders<T extends Record<string, unknown> | string>(items: Record<string, T>, orderField?: OrderFieldParam): Record<string, string> | null;
+
+export { fractionalIndex, healDuplicateOrders, sortByOrder };

package/dist/fractionalIndex.js

@@ -0,0 +1,241 @@
+import "./chunk-IZ2YBCUP.js";
+const digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const INTEGER_ZERO = "a0";
+const SMALLEST_INTEGER = "A00000000000000000000000000";
+const LARGEST_INTEGER = "zzzzzzzzzzzzzzzzzzzzzzzzzzz";
+const ZERO = digits[0];
+fractionalIndex.sort = sortByOrder;
+fractionalIndex.heal = healDuplicateOrders;
+function fractionalIndex(a, b, count) {
+  if (count !== void 0) {
+    if (count === 0) {
+      return [];
+    }
+    if (count === 1) {
+      return [fractionalIndex(a, b)];
+    }
+    if (!b) {
+      let c2 = fractionalIndex(a, b);
+      const result = [c2];
+      for (let i2 = 0; i2 < count - 1; i2++) {
+        c2 = fractionalIndex(c2, b);
+        result.push(c2);
+      }
+      return result;
+    }
+    if (!a) {
+      let c2 = fractionalIndex(a, b);
+      const result = [c2];
+      for (let i2 = 0; i2 < count - 1; i2++) {
+        c2 = fractionalIndex(a, c2);
+        result.push(c2);
+      }
+      result.reverse();
+      return result;
+    }
+    const mid = Math.floor(count / 2);
+    const c = fractionalIndex(a, b);
+    return [...fractionalIndex(a, c, mid), c, ...fractionalIndex(c, b, count - mid - 1)];
+  }
+  if (a && b && a >= b) {
+    [a, b] = [b, a];
+  }
+  if (!a && !b) {
+    return INTEGER_ZERO;
+  }
+  if (a) {
+    validatestring(a, true);
+  }
+  if (b) {
+    validatestring(b, false);
+  }
+  if (!a) {
+    const ib2 = getIntegerPart(b);
+    const fb2 = b.slice(ib2.length);
+    if (ib2 === SMALLEST_INTEGER) {
+      return ib2 + midpoint("", fb2);
+    }
+    return ib2 < b ? ib2 : decrementInteger(ib2);
+  }
+  if (!b) {
+    const ia2 = getIntegerPart(a);
+    const fa2 = a.slice(ia2.length);
+    const i2 = incrementInteger(ia2);
+    return !i2 ? ia2 + midpoint(fa2, null) : i2;
+  }
+  const ia = getIntegerPart(a);
+  const fa = a.slice(ia.length);
+  const ib = getIntegerPart(b);
+  const fb = b.slice(ib.length);
+  if (ia === ib) {
+    return ia + midpoint(fa, fb);
+  }
+  const i = incrementInteger(ia);
+  return i < b ? i : ia + midpoint(fa, null);
+}
+function midpoint(a, b) {
+  if (a && b && a >= b) {
+    [a, b] = [b, a];
+  }
+  if (a && a.slice(-1) === ZERO || b && b.slice(-1) === ZERO) {
+    throw new Error("Trailing zero");
+  }
+  if (!a) a = "";
+  if (b) {
+    let n = 0;
+    while ((a[n] || ZERO) === b[n]) {
+      n++;
+    }
+    if (n > 0) {
+      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n));
+    }
+  }
+  const digitA = a ? digits.indexOf(a[0]) : 0;
+  const digitB = b ? digits.indexOf(b[0]) : digits.length;
+  if (digitB - digitA > 1) {
+    const midDigit = Math.round(0.5 * (digitA + digitB));
+    return digits[midDigit];
+  } else {
+    if (b && b.length > 1) {
+      return b.slice(0, 1);
+    } else {
+      return digits[digitA] + midpoint(a?.slice(1), null);
+    }
+  }
+}
+function getIntegerLength(head) {
+  if (head >= "a" && head <= "z") {
+    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
+  } else if (head >= "A" && head <= "Z") {
+    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
+  } else {
+    throw new Error("Invalid order key head: " + head);
+  }
+}
+function validateInteger(int) {
+  if (int.length !== getIntegerLength(int[0])) {
+    throw new Error("Invalid integer part of order key: " + int);
+  }
+}
+function incrementInteger(x) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let carry = true;
+  for (let i = digs.length - 1; carry && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) + 1;
+    if (d === digits.length) {
+      digs[i] = ZERO;
+    } else {
+      digs[i] = digits[d];
+      carry = false;
+    }
+  }
+  if (carry) {
+    if (head === "Z") {
+      return "a0";
+    }
+    if (head === "z") {
+      return "";
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) + 1);
+    if (h > "a") {
+      digs.push(ZERO);
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function decrementInteger(x) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let borrow = true;
+  for (let i = digs.length - 1; borrow && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) - 1;
+    if (d === -1) {
+      digs[i] = digits.slice(-1);
+    } else {
+      digs[i] = digits[d];
+      borrow = false;
+    }
+  }
+  if (borrow) {
+    if (head === "a") {
+      return "Z" + digits.slice(-1);
+    }
+    if (head === "A") {
+      return "";
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) - 1);
+    if (h < "Z") {
+      digs.push(digits.slice(-1));
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function getIntegerPart(key) {
+  const integerPartLength = getIntegerLength(key[0]);
+  if (integerPartLength > key.length) {
+    throw new Error("Invalid order key: " + key);
+  }
+  return key.slice(0, integerPartLength);
+}
+function validatestring(key, lowValue) {
+  if (lowValue && key === LARGEST_INTEGER || !lowValue && key === SMALLEST_INTEGER) {
+    throw new Error("Invalid order key: " + key);
+  }
+  const i = getIntegerPart(key);
+  const f = key.slice(i.length);
+  if (f.slice(-1) === ZERO) {
+    throw new Error("Invalid order key: " + key);
+  }
+}
+function createOrderGetter(orderField) {
+  return orderField === false ? (value) => value : (value) => value[orderField];
+}
+function sortByOrder(items, orderField = "order") {
+  const getOrder = createOrderGetter(orderField);
+  return Object.entries(items).sort((a, b) => {
+    const orderCmp = getOrder(a[1]).localeCompare(getOrder(b[1]));
+    if (orderCmp !== 0) return orderCmp;
+    return a[0].localeCompare(b[0]);
+  });
+}
+function healDuplicateOrders(items, orderField = "order") {
+  const getOrder = createOrderGetter(orderField);
+  const fixes = {};
+  const entries = sortByOrder(items, orderField);
+  if (entries.length < 2) return null;
+  let prevOrder = getOrder(entries[0][1]);
+  for (let i = 1; i < entries.length; i++) {
+    const [key, item] = entries[i];
+    const currentOrder = getOrder(item);
+    if (currentOrder <= prevOrder) {
+      let nextOrder = null;
+      for (let j = i + 1; j < entries.length; j++) {
+        const candidateOrder = getOrder(entries[j][1]);
+        if (candidateOrder > prevOrder) {
+          nextOrder = candidateOrder;
+          break;
+        }
+      }
+      const newOrder = fractionalIndex(prevOrder, nextOrder);
+      fixes[key] = newOrder;
+      prevOrder = newOrder;
+    } else {
+      prevOrder = currentOrder;
+    }
+  }
+  return Object.keys(fixes).length > 0 ? fixes : null;
+}
+export {
+  fractionalIndex,
+  healDuplicateOrders,
+  sortByOrder
+};

package/dist/index.d.ts

@@ -1,13 +1,24 @@
 export { Delta } from '@dabble/delta';
-export { IndexedDBStore } from './client/IndexedDBStore.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from './BaseDoc-DkP3tUhT.js';
+export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createAllIndexedDBPatches, createAllPatches, createLWWIndexedDBPatches, createLWWPatches, createOTIndexedDBPatches, createOTPatches } from './client/factories.js';
+export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
+export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';
+export { LWWIndexedDBStore } from './client/LWWIndexedDBStore.js';
 export { InMemoryStore } from './client/InMemoryStore.js';
+export { LWWInMemoryStore } from './client/LWWInMemoryStore.js';
+export { LWWDoc } from './client/LWWDoc.js';
+export { LWWAlgorithm } from './client/LWWAlgorithm.js';
+export { OTAlgorithm } from './client/OTAlgorithm.js';
 export { Patches, PatchesOptions } from './client/Patches.js';
-export { PatchesDoc, PatchesDocOptions } from './client/PatchesDoc.js';
 export { PatchesHistoryClient } from './client/PatchesHistoryClient.js';
 export { PatchesStore, TrackedDoc } from './client/PatchesStore.js';
+export { OTClientStore } from './client/OTClientStore.js';
+export { LWWClientStore } from './client/LWWClientStore.js';
+export { AlgorithmName, ClientAlgorithm } from './client/ClientAlgorithm.js';
 export { createChange } from './data/change.js';
 export { createVersionId, createVersionMetadata } from './data/version.js';
 export { ErrorSubscriber, Signal, SignalSubscriber, Unsubscriber, signal } from './event-signal.js';
+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';
@@ -18,7 +29,6 @@ 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 { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata } from './types.js';
-export { clampTimestamp, extractTimezoneOffset, getISO, getLocalISO, getLocalTimezoneOffset, timestampDiff } from './utils/dates.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';
@@ -28,5 +38,4 @@ 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 './algorithms/shared/changeBatching.js';
 import './net/protocol/types.js';

package/dist/index.js

@@ -4,8 +4,8 @@ export * from "./client/index.js";
 export * from "./data/change.js";
 export * from "./data/version.js";
 export * from "./event-signal.js";
+export * from "./fractionalIndex.js";
 export * from "./json-patch/index.js";
-export * from "./utils/dates.js";
 export {
   Delta
 };

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

@@ -40,6 +40,8 @@ interface JSONPatchOp {
     from?: string;
     value?: any;
     soft?: boolean;
+    ts?: number;
+    rev?: number;
 }
 interface Root {
     '': any;

package/dist/net/PatchesClient.js

@@ -33,7 +33,7 @@ class PatchesClient {
    * @returns A promise resolving with the list of successfully subscribed document IDs.
    */
   async subscribe(ids) {
-    return this.rpc.call("subscribe", { ids });
+    return this.rpc.call("subscribe", ids);
   }
   /**
    * Unsubscribes the client from one or more documents.
@@ -41,7 +41,7 @@ class PatchesClient {
    * @returns A promise resolving when the unsubscription is confirmed.
    */
   async unsubscribe(ids) {
-    return this.rpc.call("unsubscribe", { ids });
+    return this.rpc.call("unsubscribe", ids);
   }
   // === Document Operations ===
   /**
@@ -50,7 +50,7 @@ class PatchesClient {
    * @returns A promise resolving with the document snapshot.
    */
   async getDoc(docId, atRev) {
-    return this.rpc.call("getDoc", { docId, atRev });
+    return this.rpc.call("getDoc", docId, atRev);
   }
   /**
    * Gets changes that occurred for a document after a specific revision number.
@@ -59,7 +59,7 @@ class PatchesClient {
    * @returns A promise resolving with an array of changes.
    */
   async getChangesSince(docId, rev) {
-    return this.rpc.call("getChangesSince", { docId, rev });
+    return this.rpc.call("getChangesSince", docId, rev);
   }
   /**
    * Applies a set of client-generated changes to a document on the server.
@@ -69,7 +69,7 @@ class PatchesClient {
    * @returns A promise resolving with the changes as committed by the server (potentially transformed).
    */
   async commitChanges(docId, changes, options) {
-    return this.rpc.call("commitChanges", { docId, changes, options });
+    return this.rpc.call("commitChanges", docId, changes, options);
   }
   /**
    * Deletes a document on the server.
@@ -78,7 +78,7 @@ class PatchesClient {
    * @returns A promise resolving when the deletion is confirmed.
    */
   async deleteDoc(docId, options) {
-    return this.rpc.call("deleteDoc", { docId, options });
+    return this.rpc.call("deleteDoc", docId, options);
   }
   // === Version Operations ===
   /**
@@ -88,7 +88,7 @@ class PatchesClient {
    * @returns A promise resolving with the unique ID of the newly created version.
    */
   async createVersion(docId, metadata) {
-    return this.rpc.call("createVersion", { docId, metadata });
+    return this.rpc.call("createVersion", docId, metadata);
   }
   /**
    * Lists metadata for saved versions of a document.
@@ -97,7 +97,7 @@ class PatchesClient {
    * @returns A promise resolving with an array of version metadata objects.
    */
   async listVersions(docId, options) {
-    return this.rpc.call("listVersions", { docId, options });
+    return this.rpc.call("listVersions", docId, options);
   }
   /**
    * Gets the document state snapshot corresponding to a specific version ID.
@@ -106,7 +106,7 @@ class PatchesClient {
    * @returns A promise resolving with the document snapshot for that version.
    */
   async getVersionState(docId, versionId) {
-    return this.rpc.call("getVersionState", { docId, versionId });
+    return this.rpc.call("getVersionState", docId, versionId);
   }
   /**
    * Gets the original changes associated with a specific version ID.
@@ -115,7 +115,7 @@ class PatchesClient {
    * @returns A promise resolving with an array of changes that constitute that version.
    */
   async getVersionChanges(docId, versionId) {
-    return this.rpc.call("getVersionChanges", { docId, versionId });
+    return this.rpc.call("getVersionChanges", docId, versionId);
   }
   /**
    * Updates the name of a specific version.
@@ -125,7 +125,7 @@ class PatchesClient {
    * @returns A promise resolving when the update is confirmed.
    */
   async updateVersion(docId, versionId, metadata) {
-    return this.rpc.call("updateVersion", { docId, versionId, metadata });
+    return this.rpc.call("updateVersion", docId, versionId, metadata);
   }
   // === Branch Operations ===
   /**
@@ -134,7 +134,7 @@ class PatchesClient {
    * @returns A promise resolving with an array of branch metadata objects.
    */
   async listBranches(docId) {
-    return this.rpc.call("listBranches", { docId });
+    return this.rpc.call("listBranches", docId);
   }
   /**
    * Creates a new branch for a document.
@@ -144,7 +144,7 @@ class PatchesClient {
    * @returns A promise resolving with the unique ID of the newly created branch.
    */
   async createBranch(docId, rev, metadata) {
-    return this.rpc.call("createBranch", { docId, rev, metadata });
+    return this.rpc.call("createBranch", docId, rev, metadata);
   }
   /**
    * Closes a branch on the server.
@@ -152,7 +152,7 @@ class PatchesClient {
    * @returns A promise resolving when the branch is closed.
    */
   async closeBranch(branchId) {
-    return this.rpc.call("closeBranch", { branchId });
+    return this.rpc.call("closeBranch", branchId);
   }
   /**
    * Merges a branch on the server.
@@ -160,7 +160,7 @@ class PatchesClient {
    * @returns A promise resolving when the merge is confirmed.
    */
   async mergeBranch(branchId) {
-    return this.rpc.call("mergeBranch", { branchId });
+    return this.rpc.call("mergeBranch", branchId);
   }
 }
 export {