@dabble/patches 0.5.1 → 0.5.3

package/dist/algorithms/client/makeChange.js

@@ -1,7 +1,7 @@
 import "../../chunk-IZ2YBCUP.js";
 import { createChange } from "../../data/change.js";
 import { createJSONPatch } from "../../json-patch/createJSONPatch.js";
-import { breakChange } from "./breakChange.js";
+import { breakChanges } from "../shared/changeBatching.js";
 import { createStateFromSnapshot } from "./createStateFromSnapshot.js";
 function makeChange(snapshot, mutator, changeMetadata, maxPayloadBytes) {
   const pendingChanges = snapshot.changes;
@@ -20,7 +20,7 @@ function makeChange(snapshot, mutator, changeMetadata, maxPayloadBytes) {
     throw new Error(`Failed to apply change to state during makeChange: ${error}`);
   }
   if (maxPayloadBytes) {
-    newChangesArray = breakChange(newChangesArray[0], maxPayloadBytes);
+    newChangesArray = breakChanges(newChangesArray, maxPayloadBytes);
   }
   return newChangesArray;
 }

package/dist/algorithms/server/commitChanges.d.ts

@@ -1,5 +1,5 @@
 import { PatchesStoreBackend } from '../../server/types.js';
-import { ChangeInput, Change } from '../../types.js';
+import { ChangeInput, CommitChangesOptions, Change } from '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
@@ -9,10 +9,11 @@ import '../../json-patch/types.js';
  * @param docId - The ID of the document.
  * @param changes - The changes to commit.
  * @param originClientId - The ID of the client that initiated the commit.
+ * @param options - Optional commit settings.
  * @returns A tuple of [committedChanges, transformedChanges] where:
  *   - committedChanges: Changes that were already committed to the server after the client's base revision
  *   - transformedChanges: The client's changes after being transformed against concurrent changes
  */
-declare function commitChanges(store: PatchesStoreBackend, docId: string, changes: ChangeInput[], sessionTimeoutMillis: number): Promise<[Change[], Change[]]>;
+declare function commitChanges(store: PatchesStoreBackend, docId: string, changes: ChangeInput[], sessionTimeoutMillis: number, options?: CommitChangesOptions, maxPayloadBytes?: number): Promise<[Change[], Change[]]>;
 
-export { commitChanges };
+export { CommitChangesOptions, commitChanges };

package/dist/algorithms/server/commitChanges.js

@@ -1,12 +1,12 @@
 import "../../chunk-IZ2YBCUP.js";
-import { clampTimestamp, createServerTimestamp, timestampDiff } from "../../utils/dates.js";
+import { clampTimestamp, getISO, timestampDiff } from "../../utils/dates.js";
 import { applyChanges } from "../shared/applyChanges.js";
 import { createVersion } from "./createVersion.js";
 import { getSnapshotAtRevision } from "./getSnapshotAtRevision.js";
 import { getStateAtRevision } from "./getStateAtRevision.js";
 import { handleOfflineSessionsAndBatches } from "./handleOfflineSessionsAndBatches.js";
 import { transformIncomingChanges } from "./transformIncomingChanges.js";
-async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
+async function commitChanges(store, docId, changes, sessionTimeoutMillis, options, maxPayloadBytes) {
   if (changes.length === 0) {
     return [[], []];
   }
@@ -15,7 +15,7 @@ async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
   const currentState = applyChanges(initialState, currentChanges);
   const currentRev = currentChanges.at(-1)?.rev ?? initialRev;
   const baseRev = changes[0].baseRev ?? currentRev;
-  const serverNow = createServerTimestamp();
+  const serverNow = getISO();
   let rev = baseRev + 1;
   changes.forEach((c) => {
     if (c.baseRev == null) c.baseRev = baseRev;
@@ -24,8 +24,10 @@ async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
     }
     if (c.rev == null) c.rev = rev++;
     else rev = c.rev + 1;
-    c.committedAt = serverNow;
-    c.createdAt = clampTimestamp(c.createdAt, serverNow);
+    if (!options?.historicalImport || !c.committedAt) {
+      c.committedAt = serverNow;
+    }
+    c.createdAt = c.createdAt ? clampTimestamp(c.createdAt, serverNow) : serverNow;
   });
   if (baseRev > currentRev) {
     throw new Error(
@@ -39,7 +41,8 @@ async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
     );
   }
   const lastChange = currentChanges[currentChanges.length - 1];
-  if (lastChange && timestampDiff(serverNow, lastChange.createdAt) > sessionTimeoutMillis) {
+  const compareTime = options?.historicalImport ? changes[0].createdAt : serverNow;
+  if (lastChange && timestampDiff(compareTime, lastChange.createdAt) > sessionTimeoutMillis) {
     await createVersion(store, docId, currentState, currentChanges);
   }
   const committedChanges = await store.listChanges(docId, {
@@ -53,17 +56,33 @@ async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
   }
   const isOfflineTimestamp = timestampDiff(serverNow, incomingChanges[0].createdAt) > sessionTimeoutMillis;
   if (isOfflineTimestamp || batchId) {
+    const canFastForward = committedChanges.length === 0;
+    const origin = options?.historicalImport ? "main" : canFastForward ? "main" : "offline-branch";
     incomingChanges = await handleOfflineSessionsAndBatches(
       store,
       sessionTimeoutMillis,
       docId,
       incomingChanges,
       baseRev,
-      batchId
+      batchId,
+      origin,
+      true,
+      // isOffline
+      maxPayloadBytes
     );
+    if (canFastForward) {
+      await store.saveChanges(docId, incomingChanges);
+      return [[], incomingChanges];
+    }
   }
   const stateAtBaseRev = (await getStateAtRevision(store, docId, baseRev)).state;
-  const transformedChanges = transformIncomingChanges(incomingChanges, stateAtBaseRev, committedChanges, currentRev);
+  const transformedChanges = transformIncomingChanges(
+    incomingChanges,
+    stateAtBaseRev,
+    committedChanges,
+    currentRev,
+    options?.forceCommit
+  );
   if (transformedChanges.length > 0) {
     await store.saveChanges(docId, transformedChanges);
   }

package/dist/algorithms/server/createVersion.js

@@ -1,5 +1,6 @@
 import "../../chunk-IZ2YBCUP.js";
 import { createVersionMetadata } from "../../data/version.js";
+import { getISO } from "../../utils/dates.js";
 async function createVersion(store, docId, state, changes, metadata) {
   if (changes.length === 0) return;
   const baseRev = changes[0].baseRev;
@@ -9,8 +10,8 @@ async function createVersion(store, docId, state, changes, metadata) {
   const sessionMetadata = createVersionMetadata({
     origin: "main",
     // Convert client timestamps to UTC for version metadata (enables lexicographic sorting)
-    startedAt: new Date(changes[0].createdAt).toISOString(),
-    endedAt: new Date(changes[changes.length - 1].createdAt).toISOString(),
+    startedAt: getISO(changes[0].createdAt),
+    endedAt: getISO(changes[changes.length - 1].createdAt),
     rev: changes[changes.length - 1].rev,
     baseRev,
     ...metadata

package/dist/algorithms/server/handleOfflineSessionsAndBatches.d.ts

@@ -11,8 +11,11 @@ import '../../json-patch/types.js';
  * @param changes The incoming changes (all with the same batchId)
  * @param baseRev The base revision for the batch
  * @param batchId The batch identifier
- * @returns The collapsed changes for transformation
+ * @param origin The origin to use for created versions (default: 'offline-branch')
+ * @param isOffline Whether these changes were created offline (metadata flag)
+ * @param maxPayloadBytes If set, break collapsed changes that exceed this size
+ * @returns The changes (collapsed into one if divergent, unchanged if fast-forward)
  */
-declare function handleOfflineSessionsAndBatches(store: PatchesStoreBackend, sessionTimeoutMillis: number, docId: string, changes: Change[], baseRev: number, batchId?: string): Promise<Change[]>;
+declare function handleOfflineSessionsAndBatches(store: PatchesStoreBackend, sessionTimeoutMillis: number, docId: string, changes: Change[], baseRev: number, batchId?: string, origin?: 'main' | 'offline-branch', isOffline?: boolean, maxPayloadBytes?: number): Promise<Change[]>;
 
 export { handleOfflineSessionsAndBatches };

package/dist/algorithms/server/handleOfflineSessionsAndBatches.js

@@ -1,10 +1,11 @@
 import "../../chunk-IZ2YBCUP.js";
 import { createSortableId } from "crypto-id";
 import { createVersionMetadata } from "../../data/version.js";
-import { timestampDiff } from "../../utils/dates.js";
+import { getISO, timestampDiff } from "../../utils/dates.js";
 import { applyChanges } from "../shared/applyChanges.js";
+import { breakChanges } from "../shared/changeBatching.js";
 import { getStateAtRevision } from "./getStateAtRevision.js";
-async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docId, changes, baseRev, batchId) {
+async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docId, changes, baseRev, batchId, origin = "offline-branch", isOffline = true, maxPayloadBytes) {
   const groupId = batchId ?? createSortableId();
   const [lastVersion] = await store.listVersions(docId, {
     groupId,
@@ -30,8 +31,9 @@ async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docI
         const isContinuation = !!lastVersion && timestampDiff(sessionChanges[0].createdAt, lastVersion.endedAt) <= sessionTimeoutMillis;
         if (isContinuation) {
           const mergedState = applyChanges(offlineBaseState, sessionChanges);
-          await store.saveChanges(docId, sessionChanges);
-          await store.updateVersion(docId, lastVersion.id, {});
+          const newEndedAt = getISO(sessionChanges[sessionChanges.length - 1].createdAt);
+          const newRev = sessionChanges[sessionChanges.length - 1].rev;
+          await store.appendVersionChanges(docId, lastVersion.id, sessionChanges, newEndedAt, newRev, mergedState);
           offlineBaseState = mergedState;
           parentId = lastVersion.parentId;
         } else {
@@ -39,10 +41,11 @@ async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docI
           const sessionMetadata = createVersionMetadata({
             parentId,
             groupId,
-            origin: "offline",
+            origin,
+            isOffline,
             // Convert client timestamps to UTC for version metadata (enables lexicographic sorting)
-            startedAt: new Date(sessionChanges[0].createdAt).toISOString(),
-            endedAt: new Date(sessionChanges[sessionChanges.length - 1].createdAt).toISOString(),
+            startedAt: getISO(sessionChanges[0].createdAt),
+            endedAt: getISO(sessionChanges[sessionChanges.length - 1].createdAt),
             rev: sessionChanges[sessionChanges.length - 1].rev,
             baseRev
           });
@@ -53,12 +56,17 @@ async function handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docI
       }
     }
   }
-  return [
-    changes.reduce((firstChange, nextChange) => {
+  if (origin === "offline-branch") {
+    const collapsed = changes.reduce((firstChange, nextChange) => {
       firstChange.ops = [...firstChange.ops, ...nextChange.ops];
       return firstChange;
-    })
-  ];
+    });
+    if (maxPayloadBytes) {
+      return breakChanges([collapsed], maxPayloadBytes);
+    }
+    return [collapsed];
+  }
+  return changes;
 }
 export {
   handleOfflineSessionsAndBatches

package/dist/algorithms/server/transformIncomingChanges.d.ts

@@ -10,8 +10,9 @@ import '../../json-patch/types.js';
  * @param stateAtBaseRev The server state *at the client's baseRev*.
  * @param committedChanges The committed changes that happened *after* the client's baseRev.
  * @param currentRev The current/latest revision number (these changes will have their `rev` set > `currentRev`).
+ * @param forceCommit If true, skip filtering of no-op changes (useful for migrations).
  * @returns The transformed changes.
  */
-declare function transformIncomingChanges(changes: Change[], stateAtBaseRev: any, committedChanges: Change[], currentRev: number): Change[];
+declare function transformIncomingChanges(changes: Change[], stateAtBaseRev: any, committedChanges: Change[], currentRev: number, forceCommit?: boolean): Change[];
 
 export { transformIncomingChanges };

package/dist/algorithms/server/transformIncomingChanges.js

@@ -1,24 +1,26 @@
 import "../../chunk-IZ2YBCUP.js";
 import { applyPatch } from "../../json-patch/applyPatch.js";
 import { transformPatch } from "../../json-patch/transformPatch.js";
-function transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev) {
+function transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev, forceCommit = false) {
   const committedOps = committedChanges.flatMap((c) => c.ops);
   let state = stateAtBaseRev;
   let rev = currentRev + 1;
   return changes.map((change) => {
     const transformedOps = transformPatch(stateAtBaseRev, committedOps, change.ops);
-    if (transformedOps.length === 0) {
+    if (transformedOps.length === 0 && !forceCommit) {
       return null;
     }
-    try {
-      const previous = state;
-      state = applyPatch(state, transformedOps, { strict: true });
-      if (previous === state) {
+    if (transformedOps.length > 0) {
+      try {
+        const previous = state;
+        state = applyPatch(state, transformedOps, { strict: true });
+        if (previous === state && !forceCommit) {
+          return null;
+        }
+      } catch (error) {
+        console.error(`Error applying change ${change.id} to state:`, error);
         return null;
       }
-    } catch (error) {
-      console.error(`Error applying change ${change.id} to state:`, error);
-      return null;
     }
     return { ...change, rev: rev++, ops: transformedOps };
   }).filter(Boolean);

package/dist/algorithms/shared/changeBatching.d.ts

@@ -0,0 +1,19 @@
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+/** Estimate JSON string byte size. */
+declare function getJSONByteSize(data: unknown): number;
+/**
+ * Break changes into smaller changes so that each change's JSON string size never exceeds `maxBytes`.
+ *
+ * - Splits first by JSON-Patch *ops*
+ * - If an individual op is still too big and is a "@txt" op,
+ *   split its Delta payload into smaller Deltas
+ */
+declare function breakChanges(changes: Change[], maxBytes: number): Change[];
+/** Break changes into batches based on maxPayloadBytes. */
+declare function breakChangesIntoBatches(changes: Change[], maxPayloadBytes?: number): Change[][];
+
+export { breakChanges, breakChangesIntoBatches, getJSONByteSize };

package/dist/algorithms/{client/breakChange.js → shared/changeBatching.js}

@@ -1,7 +1,58 @@
 import "../../chunk-IZ2YBCUP.js";
+import { createId } from "crypto-id";
 import { createChange } from "../../data/change.js";
-import { getJSONByteSize } from "./getJSONByteSize.js";
-function breakChange(orig, maxBytes) {
+function getJSONByteSize(data) {
+  try {
+    const stringified = JSON.stringify(data);
+    return stringified ? new TextEncoder().encode(stringified).length : 0;
+  } catch (e) {
+    console.error("Error calculating JSON size:", e);
+    throw new Error("Error calculating JSON size: " + e);
+  }
+}
+function breakChanges(changes, maxBytes) {
+  const results = [];
+  for (const change of changes) {
+    results.push(...breakSingleChange(change, maxBytes));
+  }
+  return results;
+}
+function breakChangesIntoBatches(changes, maxPayloadBytes) {
+  if (!maxPayloadBytes || getJSONByteSize(changes) < maxPayloadBytes) {
+    return [changes];
+  }
+  const batchId = createId(12);
+  const batches = [];
+  let currentBatch = [];
+  let currentSize = 2;
+  for (const change of changes) {
+    const changeWithBatchId = { ...change, batchId };
+    const individualActualSize = getJSONByteSize(changeWithBatchId);
+    let itemsToProcess;
+    if (individualActualSize > maxPayloadBytes) {
+      itemsToProcess = breakSingleChange(changeWithBatchId, maxPayloadBytes).map((c) => ({ ...c, batchId }));
+    } else {
+      itemsToProcess = [changeWithBatchId];
+    }
+    for (const item of itemsToProcess) {
+      const itemActualSize = getJSONByteSize(item);
+      const itemSizeForBatching = itemActualSize + (currentBatch.length > 0 ? 1 : 0);
+      if (currentBatch.length > 0 && currentSize + itemSizeForBatching > maxPayloadBytes) {
+        batches.push(currentBatch);
+        currentBatch = [];
+        currentSize = 2;
+      }
+      const actualItemContribution = itemActualSize + (currentBatch.length > 0 ? 1 : 0);
+      currentBatch.push(item);
+      currentSize += actualItemContribution;
+    }
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return batches;
+}
+function breakSingleChange(orig, maxBytes) {
   if (getJSONByteSize(orig) <= maxBytes) return [orig];
   const byOps = [];
   let group = [];
@@ -205,5 +256,7 @@ function deriveNewChange(origChange, rev, ops) {
   return createChange(origChange.baseRev, rev, ops, metadata);
 }
 export {
-  breakChange
+  breakChanges,
+  breakChangesIntoBatches,
+  getJSONByteSize
 };

package/dist/data/change.js

@@ -1,7 +1,7 @@
 import "../chunk-IZ2YBCUP.js";
 import { inc } from "alphacounter";
 import { createId } from "crypto-id";
-import { createClientTimestamp } from "../utils/dates.js";
+import { getLocalISO } from "../utils/dates.js";
 function createChangeId(rev) {
   return inc.from(rev) + createId(4);
 }
@@ -10,7 +10,7 @@ function createChange(baseRev, rev, ops, metadata) {
     return {
       id: createId(8),
       ops: baseRev,
-      createdAt: createClientTimestamp(),
+      createdAt: getLocalISO(),
       ...rev
     };
   } else {
@@ -19,7 +19,7 @@ function createChange(baseRev, rev, ops, metadata) {
       baseRev,
       rev,
       ops,
-      createdAt: createClientTimestamp(),
+      createdAt: getLocalISO(),
       ...metadata
     };
   }

package/dist/index.d.ts

@@ -17,8 +17,8 @@ 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 { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata } from './types.js';
-export { clampTimestamp, createClientTimestamp, createServerTimestamp, extractTimezoneOffset, formatDateWithOffset, getLocalTimezoneOffset, parseTimestamp, timestampDiff } from './utils/dates.js';
+export { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, 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';

package/dist/net/PatchesClient.d.ts

@@ -1,5 +1,5 @@
 import { Signal } from '../event-signal.js';
-import { Change, PatchesState, ChangeInput, EditableVersionMetadata, ListVersionsOptions, VersionMetadata, PatchesSnapshot } from '../types.js';
+import { Change, PatchesState, ChangeInput, CommitChangesOptions, EditableVersionMetadata, ListVersionsOptions, VersionMetadata, PatchesSnapshot } from '../types.js';
 import { JSONRPCClient } from './protocol/JSONRPCClient.js';
 import { PatchesAPI, ClientTransport } from './protocol/types.js';
 import '../json-patch/JSONPatch.js';
@@ -52,9 +52,10 @@ declare class PatchesClient implements PatchesAPI {
      * Applies a set of client-generated changes to a document on the server.
      * @param docId - The ID of the document.
      * @param changes - An array of changes to apply.
+     * @param options - Optional commit settings (e.g., forceCommit for migrations).
      * @returns A promise resolving with the changes as committed by the server (potentially transformed).
      */
-    commitChanges(docId: string, changes: ChangeInput[]): Promise<Change[]>;
+    commitChanges(docId: string, changes: ChangeInput[], options?: CommitChangesOptions): Promise<Change[]>;
     /**
      * Deletes a document on the server.
      * @param docId - The ID of the document to delete.

package/dist/net/PatchesClient.js

@@ -60,10 +60,11 @@ class PatchesClient {
    * Applies a set of client-generated changes to a document on the server.
    * @param docId - The ID of the document.
    * @param changes - An array of changes to apply.
+   * @param options - Optional commit settings (e.g., forceCommit for migrations).
    * @returns A promise resolving with the changes as committed by the server (potentially transformed).
    */
-  async commitChanges(docId, changes) {
-    return this.rpc.call("commitChanges", { docId, changes });
+  async commitChanges(docId, changes, options) {
+    return this.rpc.call("commitChanges", { docId, changes, options });
   }
   /**
    * Deletes a document on the server.

package/dist/net/PatchesSync.js

@@ -8,7 +8,7 @@ import {
 var __receiveCommittedChanges_dec, _syncDoc_dec, _init;
 import { isEqual } from "@dabble/delta";
 import { applyCommittedChanges } from "../algorithms/client/applyCommittedChanges.js";
-import { breakIntoBatches } from "../algorithms/client/batching.js";
+import { breakChangesIntoBatches } from "../algorithms/shared/changeBatching.js";
 import { Patches } from "../client/Patches.js";
 import { signal } from "../event-signal.js";
 import { blockable } from "../utils/concurrency.js";
@@ -185,7 +185,7 @@ class PatchesSync {
       if (!pending.length) {
         return;
       }
-      const batches = breakIntoBatches(pending, this.maxPayloadBytes);
+      const batches = breakChangesIntoBatches(pending, this.maxPayloadBytes);
       for (const batch of batches) {
         if (!this.state.connected) {
           throw new Error("Disconnected during flush");

package/dist/net/index.d.ts

@@ -10,14 +10,11 @@ export { Access, AuthContext, AuthorizationProvider, allowAll, denyAll } from '.
 export { onlineState } from './websocket/onlineState.js';
 export { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
 export { RPCServer, RPCServerOptions } from './websocket/RPCServer.js';
-export { JsonRpcMessage, SendFn, SignalingService } from './websocket/SignalingService.js';
+export { JsonRpcMessage, SignalingService } from './websocket/SignalingService.js';
 export { WebSocketServer } from './websocket/WebSocketServer.js';
 export { WebSocketOptions, WebSocketTransport } from './websocket/WebSocketTransport.js';
+export { CommitChangesOptions } from '../types.js';
 import '../event-signal.js';
-import '../types.js';
-import '../json-patch/JSONPatch.js';
-import '@dabble/delta';
-import '../json-patch/types.js';
 import '../client/Patches.js';
 import '../client/PatchesDoc.js';
 import '../client/PatchesStore.js';
@@ -25,3 +22,6 @@ import '../server/PatchesBranchManager.js';
 import '../server/PatchesServer.js';
 import '../server/types.js';
 import '../server/PatchesHistoryManager.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';

package/dist/net/protocol/types.d.ts

@@ -1,5 +1,5 @@
 import { Unsubscriber } from '../../event-signal.js';
-import { PatchesState, Change, ChangeInput, EditableVersionMetadata, ListVersionsOptions, VersionMetadata } from '../../types.js';
+import { PatchesState, Change, ChangeInput, CommitChangesOptions, EditableVersionMetadata, ListVersionsOptions, VersionMetadata } from '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../../json-patch/types.js';
@@ -123,7 +123,7 @@ interface PatchesAPI {
     /** Get changes that occurred after a specific revision. */
     getChangesSince(docId: string, rev: number): Promise<Change[]>;
     /** Apply a set of changes from the client to a document. Returns the committed changes. */
-    commitChanges(docId: string, changes: ChangeInput[]): Promise<Change[]>;
+    commitChanges(docId: string, changes: ChangeInput[], options?: CommitChangesOptions): Promise<Change[]>;
     /** Delete a document. */
     deleteDoc(docId: string): Promise<void>;
     /** Create a new named version snapshot of a document's current state. */
@@ -153,4 +153,4 @@ interface SignalNotificationParams {
     data: any;
 }
 
-export type { AwarenessUpdateNotificationParams, ClientTransport, ConnectionState, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListOptions, Message, PatchesAPI, PatchesNotificationParams, ServerTransport, SignalNotificationParams };
+export { type AwarenessUpdateNotificationParams, type ClientTransport, CommitChangesOptions, type ConnectionState, type JsonRpcNotification, type JsonRpcRequest, type JsonRpcResponse, type ListOptions, type Message, type PatchesAPI, type PatchesNotificationParams, type ServerTransport, type SignalNotificationParams };

package/dist/net/websocket/RPCServer.d.ts

@@ -1,4 +1,4 @@
-import { PatchesState, Change, ListVersionsOptions, VersionMetadata, EditableVersionMetadata, ListChangesOptions, Branch } from '../../types.js';
+import { PatchesState, Change, CommitChangesOptions, ListVersionsOptions, VersionMetadata, EditableVersionMetadata, ListChangesOptions, Branch } from '../../types.js';
 import { PatchesBranchManager } from '../../server/PatchesBranchManager.js';
 import { PatchesHistoryManager } from '../../server/PatchesHistoryManager.js';
 import { PatchesServer } from '../../server/PatchesServer.js';
@@ -64,10 +64,12 @@ declare class RPCServer {
      * @param params - The change parameters
      * @param params.docId - The ID of the document
      * @param params.changes - An array of changes to apply
+     * @param params.options - Optional commit settings (e.g., forceCommit for migrations)
      */
     commitChanges(params: {
         docId: string;
         changes: Change[];
+        options?: CommitChangesOptions;
     }, ctx?: AuthContext): Promise<Change[]>;
     /**
      * Deletes a document on the server.

package/dist/net/websocket/RPCServer.js

@@ -76,11 +76,12 @@ class RPCServer {
    * @param params - The change parameters
    * @param params.docId - The ID of the document
    * @param params.changes - An array of changes to apply
+   * @param params.options - Optional commit settings (e.g., forceCommit for migrations)
    */
   async commitChanges(params, ctx) {
-    const { docId, changes } = params;
+    const { docId, changes, options } = params;
     await this.assertWrite(ctx, docId, "commitChanges", params);
-    const [priorChanges, newChanges] = await this.patches.commitChanges(docId, changes, ctx?.clientId);
+    const [priorChanges, newChanges] = await this.patches.commitChanges(docId, changes, options, ctx?.clientId);
     return [...priorChanges, ...newChanges];
   }
   /**

package/dist/net/websocket/SignalingService.d.ts

@@ -7,30 +7,38 @@ import '../../json-patch/types.js';
 
 /** Union type for all possible JSON-RPC message types */
 type JsonRpcMessage = JsonRpcRequest | JsonRpcResponse;
-/** Function type for sending JSON-RPC messages */
-type SendFn = (message: JsonRpcMessage) => void;
 /**
  * Service that facilitates WebRTC connection establishment by relaying signaling messages.
  * Acts as a central hub for WebRTC peers to exchange connection information.
  */
-declare class SignalingService {
-    private clients;
+declare abstract class SignalingService {
+    protected clients: Set<string>;
+    abstract send(id: string, message: JsonRpcMessage): void | Promise<void>;
+    /**
+     * Returns the list of all connected client IDs.
+     * @returns Array of client IDs
+     */
+    getClients(): Promise<Set<string>>;
+    /**
+     * Sets the list of all connected client IDs.
+     * @param clients - Set of client IDs
+     */
+    setClients(clients: Set<string>): Promise<void>;
     /**
      * Registers a new client connection with the signaling service.
      * Assigns a unique ID to the client and informs them of other connected peers.
      *
-     * @param send - Function to send messages to this client
      * @param id - Optional client ID (generated if not provided)
      * @returns The client's assigned ID
      */
-    onClientConnected(send: SendFn, id?: string): string;
+    onClientConnected(id?: string): Promise<string>;
     /**
      * Handles a client disconnection by removing them from the registry
      * and notifying all other connected clients.
      *
      * @param id - ID of the disconnected client
      */
-    onClientDisconnected(id: string): void;
+    onClientDisconnected(id: string): Promise<void>;
     /**
      * Handles a signaling message from a client, relaying WebRTC session data
      * between peers to facilitate connection establishment.
@@ -39,33 +47,25 @@ declare class SignalingService {
      * @param message - The JSON-RPC message or its string representation
      * @returns True if the message was a valid signaling message and was handled, false otherwise
      */
-    handleClientMessage(fromId: string, message: string | JsonRpcRequest): boolean;
+    handleClientMessage(fromId: string, message: string | JsonRpcRequest): Promise<boolean>;
     /**
      * Sends a successful JSON-RPC response to a client.
      *
-     * @private
+     * @protected
      * @param toId - ID of the client to send the response to
      * @param id - Request ID to match in the response
      * @param result - Result data to include in the response
      */
-    private respond;
+    protected respond(toId: string, id: number, result: any): Promise<void>;
     /**
      * Sends an error JSON-RPC response to a client.
      *
-     * @private
+     * @protected
      * @param toId - ID of the client to send the error response to
      * @param id - Request ID to match in the response, or undefined for notifications
      * @param message - Error message to include
      */
-    private respondError;
-    /**
-     * Broadcasts a message to all connected clients, optionally excluding one.
-     *
-     * @private
-     * @param message - The message to broadcast
-     * @param excludeId - Optional ID of a client to exclude from the broadcast
-     */
-    private broadcast;
+    protected respondError(toId: string, id: number | undefined, message: string): Promise<void>;
 }
 
-export { type JsonRpcMessage, type SendFn, SignalingService };
+export { type JsonRpcMessage, SignalingService };