@dabble/patches 0.5.2 → 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

@@ -6,7 +6,7 @@ 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 [[], []];
   }
@@ -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/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

@@ -3,8 +3,9 @@ import { createSortableId } from "crypto-id";
 import { createVersionMetadata } from "../../data/version.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,7 +41,8 @@ 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: getISO(sessionChanges[0].createdAt),
             endedAt: getISO(sessionChanges[sessionChanges.length - 1].createdAt),
@@ -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/index.d.ts

@@ -17,7 +17,7 @@ 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 { 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';

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 };

package/dist/net/websocket/SignalingService.js

@@ -1,26 +1,41 @@
 import "../../chunk-IZ2YBCUP.js";
 import { createId } from "crypto-id";
 class SignalingService {
-  clients = /* @__PURE__ */ new Map();
+  clients = /* @__PURE__ */ new Set();
+  /**
+   * Returns the list of all connected client IDs.
+   * @returns Array of client IDs
+   */
+  async getClients() {
+    return new Set(this.clients);
+  }
+  /**
+   * Sets the list of all connected client IDs.
+   * @param clients - Set of client IDs
+   */
+  async setClients(clients) {
+    this.clients = clients;
+  }
   /**
    * 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, id = createId(14)) {
-    this.clients.set(id, { send });
+  async onClientConnected(id = createId(14)) {
+    const clients = await this.getClients();
+    clients.add(id);
+    await this.setClients(clients);
     const welcome = {
       jsonrpc: "2.0",
       method: "peer-welcome",
       params: {
         id,
-        peers: Array.from(this.clients.keys()).filter((pid) => pid !== id)
+        peers: Array.from(this.clients).filter((pid) => pid !== id)
       }
     };
-    send(welcome);
+    this.send(id, welcome);
     return id;
   }
   /**
@@ -29,13 +44,16 @@ class SignalingService {
    *
    * @param id - ID of the disconnected client
    */
-  onClientDisconnected(id) {
-    this.clients.delete(id);
-    this.broadcast({
+  async onClientDisconnected(id) {
+    const clients = await this.getClients();
+    clients.delete(id);
+    await this.setClients(clients);
+    const message = {
       jsonrpc: "2.0",
       method: "peer-disconnected",
       params: { id }
-    });
+    };
+    await Promise.all(Array.from(clients).map((clientId) => this.send(clientId, message)));
   }
   /**
    * Handles a signaling message from a client, relaying WebRTC session data
@@ -45,7 +63,7 @@ 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, message) {
+  async handleClientMessage(fromId, message) {
     let parsed;
     try {
       parsed = typeof message === "string" ? JSON.parse(message) : message;
@@ -55,8 +73,8 @@ class SignalingService {
     if (parsed.jsonrpc !== "2.0" || parsed.method !== "peer-signal" || !parsed.params?.to) return false;
     const { params, id } = parsed;
     const { to, data } = params;
-    const target = this.clients.get(to);
-    if (!target) {
+    const clients = await this.getClients();
+    if (!clients.has(to)) {
       this.respondError(fromId, id, "Target not connected");
       return true;
     }
@@ -68,62 +86,48 @@ class SignalingService {
         data
       }
     };
-    target.send(outbound);
+    await this.send(to, outbound);
     if (id !== void 0) {
-      this.respond(fromId, id, "ok");
+      await this.respond(fromId, id, "ok");
     }
     return true;
   }
   /**
    * 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
    */
-  respond(toId, id, result) {
-    const client = this.clients.get(toId);
-    if (!client) return;
+  async respond(toId, id, result) {
+    const clients = await this.getClients();
+    if (!clients.has(toId)) return;
     const response = {
       jsonrpc: "2.0",
       result,
       id
     };
-    client.send(response);
+    await this.send(toId, response);
   }
   /**
    * 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
    */
-  respondError(toId, id, message) {
+  async respondError(toId, id, message) {
     if (id === void 0) return;
-    const client = this.clients.get(toId);
-    if (!client) return;
+    const clients = await this.getClients();
+    if (!clients.has(toId)) return;
     const response = {
       jsonrpc: "2.0",
       error: { code: -32e3, message },
       id
     };
-    client.send(response);
-  }
-  /**
-   * 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
-   */
-  broadcast(message, excludeId) {
-    for (const [id, client] of this.clients.entries()) {
-      if (id !== excludeId) {
-        client.send(message);
-      }
-    }
+    await this.send(toId, response);
   }
 }
 export {

package/dist/server/PatchesBranchManager.d.ts

@@ -14,7 +14,8 @@ import '../event-signal.js';
 declare class PatchesBranchManager {
     private readonly store;
     private readonly patchesServer;
-    constructor(store: BranchingStoreBackend, patchesServer: PatchesServer);
+    private readonly maxPayloadBytes?;
+    constructor(store: BranchingStoreBackend, patchesServer: PatchesServer, maxPayloadBytes?: number | undefined);
     /**
      * Lists all open branches for a document.
      * @param docId - The ID of the document.

package/dist/server/PatchesBranchManager.js

@@ -1,12 +1,14 @@
 import "../chunk-IZ2YBCUP.js";
 import { createId } from "crypto-id";
+import { breakChanges } from "../algorithms/shared/changeBatching.js";
 import { createChange } from "../data/change.js";
 import { createVersionMetadata } from "../data/version.js";
 import { getISO } from "../utils/dates.js";
 class PatchesBranchManager {
-  constructor(store, patchesServer) {
+  constructor(store, patchesServer, maxPayloadBytes) {
     this.store = store;
     this.patchesServer = patchesServer;
+    this.maxPayloadBytes = maxPayloadBytes;
   }
   /**
    * Lists all open branches for a document.
@@ -94,15 +96,21 @@ class PatchesBranchManager {
       await this.closeBranch(branchId, "merged");
       return [];
     }
+    const sourceChanges = await this.store.listChanges(sourceDocId, {
+      startAfter: branchStartRevOnSource
+    });
+    const canFastForward = sourceChanges.length === 0;
     const branchVersions = await this.store.listVersions(branchId, { origin: "main" });
+    const versionOrigin = canFastForward ? "main" : "branch";
     let lastVersionId;
     for (const v of branchVersions) {
       const newVersionMetadata = createVersionMetadata({
         ...v,
-        origin: "branch",
+        origin: versionOrigin,
         baseRev: branchStartRevOnSource,
         groupId: branchId,
         branchName: branch.name,
+        // Keep branchName for traceability
         parentId: lastVersionId
       });
       const state = await this.store.loadVersionState(branchId, v.id);
@@ -110,15 +118,29 @@ class PatchesBranchManager {
       await this.store.createVersion(sourceDocId, newVersionMetadata, state, changes);
       lastVersionId = newVersionMetadata.id;
     }
-    const rev = branchStartRevOnSource + branchChanges.length;
-    const flattenedChange = createChange(
-      branchStartRevOnSource,
-      rev,
-      branchChanges.flatMap((c) => c.ops)
-    );
     let committedMergeChanges = [];
     try {
-      [, committedMergeChanges] = await this.patchesServer.commitChanges(sourceDocId, [flattenedChange]);
+      if (canFastForward) {
+        const adjustedChanges = branchChanges.map((c) => ({
+          ...c,
+          baseRev: branchStartRevOnSource,
+          rev: void 0
+          // Let commitChanges assign sequential revs
+        }));
+        [, committedMergeChanges] = await this.patchesServer.commitChanges(sourceDocId, adjustedChanges);
+      } else {
+        const rev = branchStartRevOnSource + branchChanges.length;
+        const flattenedChange = createChange(
+          branchStartRevOnSource,
+          rev,
+          branchChanges.flatMap((c) => c.ops)
+        );
+        let changesToCommit = [flattenedChange];
+        if (this.maxPayloadBytes) {
+          changesToCommit = breakChanges(changesToCommit, this.maxPayloadBytes);
+        }
+        [, committedMergeChanges] = await this.patchesServer.commitChanges(sourceDocId, changesToCommit);
+      }
     } catch (error) {
       console.error(`Failed to merge branch ${branchId} into ${sourceDocId}:`, error);
       throw new Error(`Merge failed: ${error instanceof Error ? error.message : String(error)}`);

package/dist/server/PatchesServer.d.ts

@@ -1,6 +1,6 @@
 import { Signal } from '../event-signal.js';
-import { Change, PatchesState, ChangeInput, ChangeMutator, EditableVersionMetadata } from '../types.js';
 import { PatchesStoreBackend } from './types.js';
+import { Change, PatchesState, ChangeInput, CommitChangesOptions, ChangeMutator, EditableVersionMetadata } from '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
@@ -15,6 +15,12 @@ interface PatchesServerOptions {
      * Defaults to 30 minutes.
      */
     sessionTimeoutMinutes?: number;
+    /**
+     * Maximum size in bytes for a single change's JSON representation.
+     * If a flattened/collapsed change exceeds this, it will be split into multiple changes.
+     * Useful for databases with row size limits.
+     */
+    maxPayloadBytes?: number;
 }
 /**
  * Handles the server-side Operational Transformation (OT) logic,
@@ -24,6 +30,7 @@ interface PatchesServerOptions {
 declare class PatchesServer {
     readonly store: PatchesStoreBackend;
     private readonly sessionTimeoutMillis;
+    private readonly maxPayloadBytes?;
     /** Notifies listeners whenever a batch of changes is *successfully* committed. */
     readonly onChangesCommitted: Signal<(docId: string, changes: Change[], originClientId?: string) => void>;
     /** Notifies listeners when a document is deleted. */
@@ -54,12 +61,13 @@ declare class PatchesServer {
      * Commits a set of changes to a document, applying operational transformation as needed.
      * @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 (e.g., forceCommit for migrations).
+     * @param originClientId - The ID of the client that initiated the commit (used by transport layer for broadcast filtering).
      * @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
      */
-    commitChanges(docId: string, changes: ChangeInput[], originClientId?: string): Promise<[Change[], Change[]]>;
+    commitChanges(docId: string, changes: ChangeInput[], options?: CommitChangesOptions, originClientId?: string): Promise<[Change[], Change[]]>;
     /**
      * Make a server-side change to a document.
      * @param mutator
@@ -82,4 +90,4 @@ declare class PatchesServer {
 }
 declare function assertVersionMetadata(metadata?: EditableVersionMetadata): void;
 
-export { PatchesServer, type PatchesServerOptions, assertVersionMetadata };
+export { CommitChangesOptions, PatchesServer, type PatchesServerOptions, assertVersionMetadata };

package/dist/server/PatchesServer.js

@@ -11,8 +11,10 @@ class PatchesServer {
   constructor(store, options = {}) {
     this.store = store;
     this.sessionTimeoutMillis = (options.sessionTimeoutMinutes ?? 30) * 60 * 1e3;
+    this.maxPayloadBytes = options.maxPayloadBytes;
   }
   sessionTimeoutMillis;
+  maxPayloadBytes;
   /** Notifies listeners whenever a batch of changes is *successfully* committed. */
   onChangesCommitted = signal();
   /** Notifies listeners when a document is deleted. */
@@ -48,17 +50,20 @@ class PatchesServer {
    * Commits a set of changes to a document, applying operational transformation as needed.
    * @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 (e.g., forceCommit for migrations).
+   * @param originClientId - The ID of the client that initiated the commit (used by transport layer for broadcast filtering).
    * @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
    */
-  async commitChanges(docId, changes, originClientId) {
+  async commitChanges(docId, changes, options, originClientId) {
     const [committedChanges, transformedChanges] = await commitChanges(
       this.store,
       docId,
       changes,
-      this.sessionTimeoutMillis
+      this.sessionTimeoutMillis,
+      options,
+      this.maxPayloadBytes
     );
     if (transformedChanges.length > 0) {
       try {

package/dist/server/index.d.ts

@@ -2,8 +2,8 @@ export { PatchesBranchManager } from './PatchesBranchManager.js';
 export { PatchesHistoryManager } from './PatchesHistoryManager.js';
 export { PatchesServer, PatchesServerOptions } from './PatchesServer.js';
 export { BranchingStoreBackend, PatchesStoreBackend } from './types.js';
-import '../types.js';
+export { CommitChangesOptions } from '../types.js';
+import '../event-signal.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
-import '../event-signal.js';

package/dist/server/types.d.ts

@@ -23,6 +23,11 @@ interface PatchesStoreBackend {
     createVersion(docId: string, metadata: VersionMetadata, state: any, changes: Change[]): Promise<void>;
     /** Update a version's metadata. */
     updateVersion(docId: string, versionId: string, metadata: EditableVersionMetadata): Promise<void>;
+    /**
+     * Appends changes to an existing version, updating its state snapshot, endedAt, and rev.
+     * Used when a session spans multiple batch submissions.
+     */
+    appendVersionChanges(docId: string, versionId: string, changes: Change[], newEndedAt: string, newRev: number, newState: any): Promise<void>;
     /** Lists version metadata based on filtering/sorting options. */
     listVersions(docId: string, options: ListVersionsOptions): Promise<VersionMetadata[]>;
     /** Loads the state snapshot for a specific version ID. */

package/dist/types.d.ts

@@ -92,8 +92,10 @@ interface VersionMetadata {
     parentId?: string;
     /** Identifier linking versions from the same offline batch or branch. */
     groupId?: string;
-    /** Indicates how the version was created ('main', 'offline', 'branch'). */
-    origin: 'main' | 'offline' | 'branch';
+    /** Indicates how the version was created ('main', 'offline-branch', 'branch'). */
+    origin: 'main' | 'offline-branch' | 'branch';
+    /** Was this version created while offline? Tracks creation context separately from timeline position. */
+    isOffline?: boolean;
     /** User-defined name if origin is 'branch'. */
     branchName?: string;
     /** Server-side ISO timestamp of version start (UTC with Z). */
@@ -111,6 +113,23 @@ type Disallowed<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & {
     [P in K]?: never;
 };
 type EditableVersionMetadata = Disallowed<VersionMetadata, 'id' | 'parentId' | 'groupId' | 'origin' | 'branchName' | 'startedAt' | 'endedAt' | 'rev' | 'baseRev'>;
+/**
+ * Options for committing changes.
+ */
+interface CommitChangesOptions {
+    /**
+     * If true, save changes even if they result in no state modification.
+     * Useful for migrations where change history must be preserved exactly.
+     */
+    forceCommit?: boolean;
+    /**
+     * Enable historical import mode for migrations. When true:
+     * - Preserves `committedAt` if provided (otherwise sets to serverNow)
+     * - Uses first incoming change's timestamp for session gap detection (not serverNow)
+     * - Creates versions with origin: 'main' instead of 'offline'
+     */
+    historicalImport?: boolean;
+}
 /**
  * Options for listing committed server changes. *Always* ordered by revision number.
  */
@@ -141,7 +160,7 @@ interface ListVersionsOptions {
     /** Return versions in descending order. Defaults to false (ascending). When reversed, startAfter and endBefore apply to the *reversed* list. */
     reverse?: boolean;
     /** Filter by the origin type. */
-    origin?: 'main' | 'offline' | 'branch';
+    origin?: 'main' | 'offline-branch' | 'branch';
     /** Filter by the group ID (branch ID or offline batch ID). */
     groupId?: string;
 }
@@ -175,4 +194,4 @@ type PathProxy<T = any> = IsAny<T> extends true ? DeepPathProxy : {
  */
 type ChangeMutator<T> = (patch: JSONPatch, root: PathProxy<T>) => void;
 
-export type { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata };
+export type { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata };

package/dist/utils/dates.js

@@ -15,6 +15,7 @@ function timestampDiff(a, b) {
   return new Date(a).getTime() - new Date(b).getTime();
 }
 function clampTimestamp(timestamp, limit) {
+  if (!timestamp || !limit) throw new Error("Timestamp and limit are required");
   const timestampDate = new Date(timestamp);
   const limitDate = new Date(limit);
   if (timestampDate <= limitDate) {
@@ -24,6 +25,7 @@ function clampTimestamp(timestamp, limit) {
   return getLocalISO(limitDate, offset);
 }
 function extractTimezoneOffset(iso) {
+  if (!iso) return "Z";
   const match = iso.match(/([+-]\d{2}:\d{2}|Z)$/);
   return match ? match[1] : "Z";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dabble/patches",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
   "author": "Jacob Wright <jacwright@gmail.com>",
   "bugs": {

package/dist/algorithms/client/batching.d.ts

@@ -1,9 +0,0 @@
-import { Change } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
-import '@dabble/delta';
-import '../../json-patch/types.js';
-
-/** Break changes into batches based on maxPayloadBytes. */
-declare function breakIntoBatches(changes: Change[], maxPayloadBytes?: number): Change[][];
-
-export { breakIntoBatches };

package/dist/algorithms/client/batching.js

@@ -1,42 +0,0 @@
-import "../../chunk-IZ2YBCUP.js";
-import { createId } from "crypto-id";
-import { breakChange } from "./breakChange.js";
-import { getJSONByteSize } from "./getJSONByteSize.js";
-function breakIntoBatches(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 = breakChange(changeWithBatchId, maxPayloadBytes);
-    } 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;
-}
-export {
-  breakIntoBatches
-};

package/dist/algorithms/client/breakChange.d.ts

@@ -1,15 +0,0 @@
-import { Change } from '../../types.js';
-import '../../json-patch/JSONPatch.js';
-import '@dabble/delta';
-import '../../json-patch/types.js';
-
-/**
- * Break a single Change into multiple Changes so that the 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 breakChange(orig: Change, maxBytes: number): Change[];
-
-export { breakChange };

package/dist/algorithms/client/getJSONByteSize.d.ts

@@ -1,4 +0,0 @@
-/** Estimate JSON string byte size. */
-declare function getJSONByteSize(data: any): number;
-
-export { getJSONByteSize };

package/dist/algorithms/client/getJSONByteSize.js

@@ -1,13 +0,0 @@
-import "../../chunk-IZ2YBCUP.js";
-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);
-  }
-}
-export {
-  getJSONByteSize
-};