@dabble/patches 0.4.4 → 0.4.6

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

@@ -1,7 +1,13 @@
-import type { PatchesSnapshot } from '../../types.js';
+import { PatchesSnapshot } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Creates the in-memory state from a snapshot.
  * @param snapshot The snapshot to create a state from.
  * @returns The new state.
  */
-export declare function createStateFromSnapshot<T = any>(snapshot: PatchesSnapshot<T>): T;
+declare function createStateFromSnapshot<T = any>(snapshot: PatchesSnapshot<T>): T;
+
+export { createStateFromSnapshot };

package/dist/algorithms/client/createStateFromSnapshot.js

@@ -1,9 +1,8 @@
-import { applyChanges } from '../shared/applyChanges.js';
-/**
- * Creates the in-memory state from a snapshot.
- * @param snapshot The snapshot to create a state from.
- * @returns The new state.
- */
-export function createStateFromSnapshot(snapshot) {
-    return applyChanges(snapshot.state, snapshot.changes);
+import "../../chunk-IZ2YBCUP.js";
+import { applyChanges } from "../shared/applyChanges.js";
+function createStateFromSnapshot(snapshot) {
+  return applyChanges(snapshot.state, snapshot.changes);
 }
+export {
+  createStateFromSnapshot
+};

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

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

package/dist/algorithms/client/getJSONByteSize.js

@@ -1,12 +1,13 @@
-/** Estimate JSON string byte size. */
-export function getJSONByteSize(data) {
-    try {
-        const stringified = JSON.stringify(data);
-        return stringified ? new TextEncoder().encode(stringified).length : 0;
-    }
-    catch (e) {
-        // Handle circular structures (from JSON.stringify) or other errors.
-        console.error('Error calculating JSON size:', e);
-        throw new Error('Error calculating JSON size: ' + e);
-    }
+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
+};

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

@@ -1,2 +1,8 @@
-import type { Change, ChangeMutator, PatchesSnapshot } from '../../types.js';
-export declare function makeChange<T = any>(snapshot: PatchesSnapshot<T>, mutator: ChangeMutator<T>, changeMetadata?: Record<string, any>, maxPayloadBytes?: number): Change[];
+import { PatchesSnapshot, ChangeMutator, Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
+declare function makeChange<T = any>(snapshot: PatchesSnapshot<T>, mutator: ChangeMutator<T>, changeMetadata?: Record<string, any>, maxPayloadBytes?: number): Change[];
+
+export { makeChange };

package/dist/algorithms/client/makeChange.js

@@ -1,37 +1,29 @@
-import { createChange } from '../../data/change.js';
-import { createJSONPatch } from '../../json-patch/createJSONPatch.js';
-import { breakChange } from './breakChange.js';
-import { createStateFromSnapshot } from './createStateFromSnapshot.js';
-export function makeChange(snapshot, mutator, changeMetadata, maxPayloadBytes) {
-    const pendingChanges = snapshot.changes;
-    const pendingRev = pendingChanges[pendingChanges.length - 1]?.rev ?? snapshot.rev;
-    const state = createStateFromSnapshot(snapshot); // Current state including pending
-    const patch = createJSONPatch(mutator);
-    if (patch.ops.length === 0) {
-        return [];
-    }
-    // Optimistic rev for local sorting, based on the latest known rev (committed or pending)
-    const rev = pendingRev + 1;
-    // Create the initial change. BaseRev is always the last *committed* revision from the snapshot.
-    let newChangesArray = [createChange(snapshot.rev, rev, patch.ops, changeMetadata)];
-    // Optimistically apply the patch to the current state (which includes pending changes)
-    // This state is temporary for validation/splitting and not stored back directly in PatchesDoc from here.
-    try {
-        // Note: The 'state' variable here is the one derived from createStateFromSnapshot (committed + pending).
-        // Applying the new patch to it is for the purpose of creating the correct Change object(s).
-        // PatchesDoc.change will apply these returned changes to its own _state later.
-        patch.apply(state); // This line primarily serves to ensure the patch is valid against the current view.
-    }
-    catch (error) {
-        console.error('Failed to apply change to state during makeChange:', error);
-        throw new Error(`Failed to apply change to state during makeChange: ${error}`);
-    }
-    if (maxPayloadBytes) {
-        // If the single change (or its parts) exceed maxPayloadBytes, break it down.
-        // breakChange will handle creating multiple Change objects if necessary,
-        // maintaining the original baseRev but incrementing revs for the pieces.
-        newChangesArray = breakChange(newChangesArray[0], maxPayloadBytes);
-    }
-    // PatchesDoc.change will take this returned array and push its contents onto its internal snapshot.
-    return newChangesArray;
+import "../../chunk-IZ2YBCUP.js";
+import { createChange } from "../../data/change.js";
+import { createJSONPatch } from "../../json-patch/createJSONPatch.js";
+import { breakChange } from "./breakChange.js";
+import { createStateFromSnapshot } from "./createStateFromSnapshot.js";
+function makeChange(snapshot, mutator, changeMetadata, maxPayloadBytes) {
+  const pendingChanges = snapshot.changes;
+  const pendingRev = pendingChanges[pendingChanges.length - 1]?.rev ?? snapshot.rev;
+  const state = createStateFromSnapshot(snapshot);
+  const patch = createJSONPatch(mutator);
+  if (patch.ops.length === 0) {
+    return [];
+  }
+  const rev = pendingRev + 1;
+  let newChangesArray = [createChange(snapshot.rev, rev, patch.ops, changeMetadata)];
+  try {
+    patch.apply(state);
+  } catch (error) {
+    console.error("Failed to apply change to state during makeChange:", error);
+    throw new Error(`Failed to apply change to state during makeChange: ${error}`);
+  }
+  if (maxPayloadBytes) {
+    newChangesArray = breakChange(newChangesArray[0], maxPayloadBytes);
+  }
+  return newChangesArray;
 }
+export {
+  makeChange
+};

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

@@ -1,5 +1,9 @@
-import type { PatchesStoreBackend } from '../../server/types.js';
-import type { Change } from '../../types.js';
+import { PatchesStoreBackend } from '../../server/types.js';
+import { ChangeInput, Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Commits a set of changes to a document, applying operational transformation as needed.
  * @param docId - The ID of the document.
@@ -9,4 +13,6 @@ import type { Change } from '../../types.js';
  *   - 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
  */
-export declare function commitChanges(store: PatchesStoreBackend, docId: string, changes: Change[], sessionTimeoutMillis: number): Promise<[Change[], Change[]]>;
+declare function commitChanges(store: PatchesStoreBackend, docId: string, changes: ChangeInput[], sessionTimeoutMillis: number): Promise<[Change[], Change[]]>;
+
+export { commitChanges };

package/dist/algorithms/server/commitChanges.js

@@ -1,80 +1,71 @@
-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';
-/**
- * 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.
- * @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
- */
-export async function commitChanges(store, docId, changes, sessionTimeoutMillis) {
-    if (changes.length === 0) {
-        return [[], []];
+import "../../chunk-IZ2YBCUP.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) {
+  if (changes.length === 0) {
+    return [[], []];
+  }
+  const batchId = changes[0].batchId;
+  const { state: initialState, rev: initialRev, changes: currentChanges } = await getSnapshotAtRevision(store, docId);
+  const currentState = applyChanges(initialState, currentChanges);
+  const currentRev = currentChanges.at(-1)?.rev ?? initialRev;
+  const baseRev = changes[0].baseRev ?? currentRev;
+  let rev = baseRev + 1;
+  changes.forEach((c) => {
+    if (c.baseRev == null) c.baseRev = baseRev;
+    else if (c.baseRev !== baseRev) {
+      throw new Error(`Client changes must have consistent baseRev in all changes for doc ${docId}.`);
     }
-    // Assume all changes share the same baseRev. Client ensures
-    const batchId = changes[0].batchId;
-    const baseRev = changes[0].baseRev;
-    if (baseRev === undefined) {
-        throw new Error(`Client changes must include baseRev for doc ${docId}.`);
-    }
-    // Add check for inconsistent baseRev within the batch if needed
-    if (changes.some(c => c.baseRev !== baseRev)) {
-        throw new Error(`Client changes must have consistent baseRev in all changes for doc ${docId}.`);
-    }
-    // 1. Load server state details (assuming store methods exist)
-    const { state: initialState, rev: initialRev, changes: currentChanges } = await getSnapshotAtRevision(store, docId);
-    const currentState = applyChanges(initialState, currentChanges);
-    const currentRev = currentChanges.at(-1)?.rev ?? initialRev;
-    // Basic validation
-    if (baseRev > currentRev) {
-        throw new Error(`Client baseRev (${baseRev}) is ahead of server revision (${currentRev}) for doc ${docId}. Client needs to reload the document.`);
-    }
-    const partOfInitialBatch = batchId && changes[0].rev > 1;
-    if (baseRev === 0 && currentRev > 0 && !partOfInitialBatch && changes[0].ops[0].path === '') {
-        throw new Error(`Client baseRev is 0 but server has already been created for doc ${docId}. Client needs to load the existing document.`);
-    }
-    // Ensure all new changes' `created` field is in the past, that each `rev` is correct, and that `baseRev` is set
-    changes.forEach(c => {
-        c.created = Math.min(c.created, Date.now());
-        c.baseRev = baseRev;
-    });
-    // 2. Check if we need to create a new version - if the last change was created more than a session ago
-    const lastChange = currentChanges[currentChanges.length - 1];
-    if (lastChange && lastChange.created < Date.now() - sessionTimeoutMillis) {
-        await createVersion(store, docId, currentState, currentChanges);
-    }
-    // 3. Load committed changes *after* the client's baseRev for transformation and idempotency checks
-    const committedChanges = await store.listChanges(docId, {
-        startAfter: baseRev,
-        withoutBatchId: batchId,
-    });
-    const committedIds = new Set(committedChanges.map(c => c.id));
-    changes = changes.filter(c => !committedIds.has(c.id));
-    // If all incoming changes were already committed, return the committed changes found
-    if (changes.length === 0) {
-        return [committedChanges, []];
-    }
-    // 4. Handle offline-session versioning:
-    // - batchId present (multi-batch uploads)
-    // - or the first change is older than the session timeout (single-batch offline)
-    const isOfflineTimestamp = changes[0].created < Date.now() - sessionTimeoutMillis;
-    if (isOfflineTimestamp || batchId) {
-        changes = await handleOfflineSessionsAndBatches(store, sessionTimeoutMillis, docId, changes, baseRev, batchId);
-    }
-    // 5. Transform the *entire batch* of incoming (and potentially collapsed offline) changes
-    //    against committed changes that happened *after* the client's baseRev.
-    //    The state used for transformation should be the server state *at the client's baseRev*.
-    const stateAtBaseRev = (await getStateAtRevision(store, docId, baseRev)).state;
-    const transformedChanges = transformIncomingChanges(changes, stateAtBaseRev, committedChanges, currentRev);
-    if (transformedChanges.length > 0) {
-        await store.saveChanges(docId, transformedChanges);
-    }
-    // Return committed changes and newly transformed changes separately
-    return [committedChanges, transformedChanges];
+    if (c.rev == null) c.rev = rev++;
+    else rev = c.rev + 1;
+    c.created = Math.min(c.created, Date.now());
+  });
+  if (baseRev > currentRev) {
+    throw new Error(
+      `Client baseRev (${baseRev}) is ahead of server revision (${currentRev}) for doc ${docId}. Client needs to reload the document.`
+    );
+  }
+  const laterPartOfAnInitialBatch = batchId && changes[0].rev > 1;
+  if (baseRev === 0 && currentRev > 0 && !laterPartOfAnInitialBatch && changes[0].ops[0]?.path === "") {
+    throw new Error(
+      `Document ${docId} already exists at rev ${currentRev}, but client is attempting to create it. Client needs to load the existing document.`
+    );
+  }
+  const lastChange = currentChanges[currentChanges.length - 1];
+  if (lastChange && lastChange.created < Date.now() - sessionTimeoutMillis) {
+    await createVersion(store, docId, currentState, currentChanges);
+  }
+  const committedChanges = await store.listChanges(docId, {
+    startAfter: baseRev,
+    withoutBatchId: batchId
+  });
+  const committedIds = new Set(committedChanges.map((c) => c.id));
+  let incomingChanges = changes.filter((c) => !committedIds.has(c.id));
+  if (incomingChanges.length === 0) {
+    return [committedChanges, []];
+  }
+  const isOfflineTimestamp = incomingChanges[0].created < Date.now() - sessionTimeoutMillis;
+  if (isOfflineTimestamp || batchId) {
+    incomingChanges = await handleOfflineSessionsAndBatches(
+      store,
+      sessionTimeoutMillis,
+      docId,
+      incomingChanges,
+      baseRev,
+      batchId
+    );
+  }
+  const stateAtBaseRev = (await getStateAtRevision(store, docId, baseRev)).state;
+  const transformedChanges = transformIncomingChanges(incomingChanges, stateAtBaseRev, committedChanges, currentRev);
+  if (transformedChanges.length > 0) {
+    await store.saveChanges(docId, transformedChanges);
+  }
+  return [committedChanges, transformedChanges];
 }
+export {
+  commitChanges
+};

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

@@ -1,5 +1,9 @@
-import type { PatchesStoreBackend } from '../../server/types.js';
-import type { Change, EditableVersionMetadata, VersionMetadata } from '../../types.js';
+import { PatchesStoreBackend } from '../../server/types.js';
+import { Change, EditableVersionMetadata, VersionMetadata } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Creates a new version snapshot of a document's state from changes.
  * @param store The storage backend to save the version to.
@@ -9,4 +13,6 @@ import type { Change, EditableVersionMetadata, VersionMetadata } from '../../typ
  * @param metadata Optional additional metadata for the version.
  * @returns The created version metadata, or undefined if no changes provided.
  */
-export declare function createVersion(store: PatchesStoreBackend, docId: string, state: any, changes: Change[], metadata?: EditableVersionMetadata): Promise<VersionMetadata | undefined>;
+declare function createVersion(store: PatchesStoreBackend, docId: string, state: any, changes: Change[], metadata?: EditableVersionMetadata): Promise<VersionMetadata | undefined>;
+
+export { createVersion };

package/dist/algorithms/server/createVersion.js

@@ -1,28 +1,22 @@
-import { createVersionMetadata } from '../../data/version.js';
-/**
- * Creates a new version snapshot of a document's state from changes.
- * @param store The storage backend to save the version to.
- * @param docId The document ID.
- * @param state The document state at the time of the version.
- * @param changes The changes since the last version that created the state.
- * @param metadata Optional additional metadata for the version.
- * @returns The created version metadata, or undefined if no changes provided.
- */
-export async function createVersion(store, docId, state, changes, metadata) {
-    if (changes.length === 0)
-        return;
-    const baseRev = changes[0].baseRev;
-    if (baseRev === undefined) {
-        throw new Error(`Client changes must include baseRev for doc ${docId}.`);
-    }
-    const sessionMetadata = createVersionMetadata({
-        origin: 'main',
-        startDate: changes[0].created,
-        endDate: changes[changes.length - 1].created,
-        rev: changes[changes.length - 1].rev,
-        baseRev,
-        ...metadata,
-    });
-    await store.createVersion(docId, sessionMetadata, state, changes);
-    return sessionMetadata;
+import "../../chunk-IZ2YBCUP.js";
+import { createVersionMetadata } from "../../data/version.js";
+async function createVersion(store, docId, state, changes, metadata) {
+  if (changes.length === 0) return;
+  const baseRev = changes[0].baseRev;
+  if (baseRev === void 0) {
+    throw new Error(`Client changes must include baseRev for doc ${docId}.`);
+  }
+  const sessionMetadata = createVersionMetadata({
+    origin: "main",
+    startDate: changes[0].created,
+    endDate: changes[changes.length - 1].created,
+    rev: changes[changes.length - 1].rev,
+    baseRev,
+    ...metadata
+  });
+  await store.createVersion(docId, sessionMetadata, state, changes);
+  return sessionMetadata;
 }
+export {
+  createVersion
+};

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

@@ -1,5 +1,9 @@
-import type { PatchesStoreBackend } from '../../server/types.js';
-import type { PatchesSnapshot } from '../../types.js';
+import { PatchesStoreBackend } from '../../server/types.js';
+import { PatchesSnapshot } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Retrieves the document state of the version before the given revision and changes after up to that revision or all
  * changes since that version.
@@ -7,4 +11,6 @@ import type { PatchesSnapshot } from '../../types.js';
  * @param rev The revision number. If not provided, the latest state, its revision, and all changes since are returned.
  * @returns The document state at the last version before the revision, its revision number, and all changes up to the specified revision (or all changes if no revision is provided).
  */
-export declare function getSnapshotAtRevision(store: PatchesStoreBackend, docId: string, rev?: number): Promise<PatchesSnapshot>;
+declare function getSnapshotAtRevision(store: PatchesStoreBackend, docId: string, rev?: number): Promise<PatchesSnapshot>;
+
+export { getSnapshotAtRevision };

package/dist/algorithms/server/getSnapshotAtRevision.js

@@ -1,29 +1,28 @@
-/**
- * Retrieves the document state of the version before the given revision and changes after up to that revision or all
- * changes since that version.
- * @param docId The document ID.
- * @param rev The revision number. If not provided, the latest state, its revision, and all changes since are returned.
- * @returns The document state at the last version before the revision, its revision number, and all changes up to the specified revision (or all changes if no revision is provided).
- */
-export async function getSnapshotAtRevision(store, docId, rev) {
-    const versions = await store.listVersions(docId, {
-        limit: 1,
-        reverse: true,
-        startAfter: rev ? rev + 1 : undefined,
-        origin: 'main',
-        orderBy: 'rev',
-    });
-    const latestMainVersion = versions[0];
-    const versionState = (latestMainVersion && (await store.loadVersionState(docId, latestMainVersion.id))) || null;
-    const versionRev = latestMainVersion?.rev ?? 0;
-    // Get *all* changes since that version up to the target revision (if specified)
-    const changesSinceVersion = await store.listChanges(docId, {
-        startAfter: versionRev,
-        endBefore: rev ? rev + 1 : undefined,
-    });
-    return {
-        state: versionState, // State from the base version
-        rev: versionRev, // Revision of the base version's state
-        changes: changesSinceVersion, // Changes that occurred *after* the base version state
-    };
+import "../../chunk-IZ2YBCUP.js";
+async function getSnapshotAtRevision(store, docId, rev) {
+  const versions = await store.listVersions(docId, {
+    limit: 1,
+    reverse: true,
+    startAfter: rev ? rev + 1 : void 0,
+    origin: "main",
+    orderBy: "rev"
+  });
+  const latestMainVersion = versions[0];
+  const versionState = latestMainVersion && await store.loadVersionState(docId, latestMainVersion.id) || null;
+  const versionRev = latestMainVersion?.rev ?? 0;
+  const changesSinceVersion = await store.listChanges(docId, {
+    startAfter: versionRev,
+    endBefore: rev ? rev + 1 : void 0
+  });
+  return {
+    state: versionState,
+    // State from the base version
+    rev: versionRev,
+    // Revision of the base version's state
+    changes: changesSinceVersion
+    // Changes that occurred *after* the base version state
+  };
 }
+export {
+  getSnapshotAtRevision
+};

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

@@ -1,9 +1,15 @@
-import type { PatchesStoreBackend } from '../../server/types.js';
-import type { PatchesState } from '../../types.js';
+import { PatchesStoreBackend } from '../../server/types.js';
+import { PatchesState } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Gets the state at a specific revision.
  * @param docId The document ID.
  * @param rev The revision number. If not provided, the latest state and its revision is returned.
  * @returns The state at the specified revision *and* its revision number.
  */
-export declare function getStateAtRevision(store: PatchesStoreBackend, docId: string, rev?: number): Promise<PatchesState>;
+declare function getStateAtRevision(store: PatchesStoreBackend, docId: string, rev?: number): Promise<PatchesState>;
+
+export { getStateAtRevision };

package/dist/algorithms/server/getStateAtRevision.js

@@ -1,18 +1,14 @@
-import { applyChanges } from '../shared/applyChanges.js';
-import { getSnapshotAtRevision } from './getSnapshotAtRevision.js';
-/**
- * Gets the state at a specific revision.
- * @param docId The document ID.
- * @param rev The revision number. If not provided, the latest state and its revision is returned.
- * @returns The state at the specified revision *and* its revision number.
- */
-export async function getStateAtRevision(store, docId, rev) {
-    // Note: _getSnapshotAtRevision now returns the state *of the version* and changes *since* it.
-    // We need to apply the changes to get the state *at* the target revision.
-    const { state: versionState, rev: snapshotRev, changes } = await getSnapshotAtRevision(store, docId, rev);
-    return {
-        // Ensure null is passed if versionState or versionState.state is null/undefined
-        state: applyChanges(versionState?.state ?? null, changes),
-        rev: changes.at(-1)?.rev ?? snapshotRev,
-    };
+import "../../chunk-IZ2YBCUP.js";
+import { applyChanges } from "../shared/applyChanges.js";
+import { getSnapshotAtRevision } from "./getSnapshotAtRevision.js";
+async function getStateAtRevision(store, docId, rev) {
+  const { state: versionState, rev: snapshotRev, changes } = await getSnapshotAtRevision(store, docId, rev);
+  return {
+    // Ensure null is passed if versionState or versionState.state is null/undefined
+    state: applyChanges(versionState?.state ?? null, changes),
+    rev: changes.at(-1)?.rev ?? snapshotRev
+  };
 }
+export {
+  getStateAtRevision
+};

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

@@ -1,5 +1,9 @@
-import type { PatchesStoreBackend } from '../../server/types.js';
-import type { Change } from '../../types.js';
+import { PatchesStoreBackend } from '../../server/types.js';
+import { Change } from '../../types.js';
+import '../../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../../json-patch/types.js';
+
 /**
  * Handles offline/large batch versioning logic for multi-batch uploads.
  * Groups changes into sessions, merges with previous batch if needed, and creates/extends versions.
@@ -9,4 +13,6 @@ import type { Change } from '../../types.js';
  * @param batchId The batch identifier
  * @returns The collapsed changes for transformation
  */
-export 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): Promise<Change[]>;
+
+export { handleOfflineSessionsAndBatches };