@dabble/patches 0.6.0 → 0.7.1

package/dist/net/serverContext.d.ts

@@ -0,0 +1,38 @@
+import { AuthContext } from './websocket/AuthorizationProvider.js';
+import '../server/types.js';
+import '../json-patch/types.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+
+/**
+ * Get the current auth context for the active request.
+ * Must be called synchronously at the start of a handler, before any await.
+ *
+ * @returns The auth context, or undefined if not in a request context
+ */
+declare function getAuthContext(): AuthContext | undefined;
+/**
+ * Set the auth context for the current request.
+ * Called by the RPC server before invoking a handler.
+ *
+ * @param ctx - The auth context to set
+ * @internal
+ */
+declare function setAuthContext(ctx: AuthContext | undefined): void;
+/**
+ * Clear the auth context after request handling completes.
+ * Called by the RPC server after a handler returns.
+ *
+ * @internal
+ */
+declare function clearAuthContext(): void;
+/**
+ * Get the client ID from the current auth context.
+ * Convenience helper for the common case of needing just the client ID.
+ *
+ * @returns The client ID, or undefined if not in a request context
+ */
+declare function getClientId(): string | undefined;
+
+export { clearAuthContext, getAuthContext, getClientId, setAuthContext };

package/dist/net/serverContext.js

@@ -0,0 +1,20 @@
+import "../chunk-IZ2YBCUP.js";
+let _ctx;
+function getAuthContext() {
+  return _ctx;
+}
+function setAuthContext(ctx) {
+  _ctx = ctx;
+}
+function clearAuthContext() {
+  _ctx = void 0;
+}
+function getClientId() {
+  return _ctx?.clientId;
+}
+export {
+  clearAuthContext,
+  getAuthContext,
+  getClientId,
+  setAuthContext
+};

package/dist/net/webrtc/WebRTCTransport.js

@@ -112,7 +112,7 @@ class WebRTCTransport {
   _connectToPeer(peerId, initiator) {
     const peer = new Peer({ initiator, trickle: false });
     peer.on("signal", (data) => {
-      this.rpc.call("peer-signal", { to: peerId, data });
+      this.rpc.call("peer-signal", peerId, data);
     });
     peer.on("connect", () => {
       this.peers.set(peerId, { id: peerId, peer, connected: true });

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

@@ -1,8 +1,8 @@
-import { PatchesStoreBackend } from '../../server/types.js';
+import { ServerStoreBackend, TombstoneStoreBackend } from '../../server/types.js';
+import '../../json-patch/types.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
 
 /**
  * Access level requested for an operation.
@@ -75,6 +75,6 @@ declare const denyAll: AuthorizationProvider;
  *   }
  * };
  */
-declare function assertNotDeleted(store: PatchesStoreBackend, docId: string): Promise<void>;
+declare function assertNotDeleted(store: ServerStoreBackend & Partial<TombstoneStoreBackend>, docId: string): Promise<void>;
 
 export { type Access, type AuthContext, type AuthorizationProvider, allowAll, assertNotDeleted, denyAll };

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

@@ -1,52 +1,61 @@
+import { JSONRPCServer } from '../protocol/JSONRPCServer.js';
 import { ServerTransport } from '../protocol/types.js';
 import { AuthorizationProvider, AuthContext } from './AuthorizationProvider.js';
-import { RPCServer } from './RPCServer.js';
 import '../../event-signal.js';
+import '../../server/types.js';
+import '../../json-patch/types.js';
 import '../../types.js';
 import '../../json-patch/JSONPatch.js';
 import '@dabble/delta';
-import '../../json-patch/types.js';
-import '../../server/types.js';
-import '../../server/PatchesBranchManager.js';
-import '../../server/PatchesServer.js';
-import '../../compression/index.js';
-import '../../algorithms/shared/lz.js';
-import '../../server/PatchesHistoryManager.js';
-import '../protocol/JSONRPCServer.js';
 
 /**
- * High-level client for the Patches real-time collaboration service.
- * This class provides document subscription, patch notification handling,
- * versioning, and other OT-specific functionality over a WebSocket connection.
+ * Options for creating a WebSocketServer instance.
+ */
+interface WebSocketServerOptions {
+    /** The transport layer for WebSocket connections */
+    transport: ServerTransport;
+    /** The JSON-RPC server for handling RPC calls */
+    rpc: JSONRPCServer;
+    /** Authorization provider for subscription access control */
+    auth?: AuthorizationProvider;
+}
+/**
+ * High-level WebSocket server for the Patches real-time collaboration service.
+ * This class provides document subscription and notification routing over a WebSocket connection.
+ * It works with a JSONRPCServer instance that handles the RPC protocol and has servers registered.
  */
 declare class WebSocketServer {
+    readonly rpc: JSONRPCServer;
     protected transport: ServerTransport;
     protected auth: AuthorizationProvider;
     /**
-     * Creates a new Patches WebSocket client instance.
+     * Creates a new Patches WebSocket server instance.
      *
-     * @param transport - The transport layer implementation that will be used for sending/receiving messages
+     * @param options - Configuration options including transport, rpc, and optional auth
+     */
+    constructor({ transport, rpc, auth }: WebSocketServerOptions);
+    /**
+     * Process an incoming message from a client.
+     * Delegates to the RPC server for handling.
      */
-    constructor(transport: ServerTransport, rpcServer: RPCServer);
+    processMessage(raw: string, ctx?: AuthContext): Promise<string | undefined>;
     /**
      * Subscribes the client to one or more documents to receive real-time updates.
      * If a document has been deleted (tombstone exists), sends immediate docDeleted notification.
-     * @param connectionId - The ID of the connection making the request
      * @param params - The subscription parameters
      * @param params.ids - Document ID or IDs to subscribe to
      */
     subscribe(params: {
         ids: string | string[];
-    }, ctx?: AuthContext): Promise<string[]>;
+    }): Promise<string[]>;
     /**
      * Unsubscribes the client from one or more documents.
-     * @param connectionId - The ID of the connection making the request
      * @param params - The unsubscription parameters
      * @param params.ids - Document ID or IDs to unsubscribe from
      */
     unsubscribe(params: {
         ids: string | string[];
-    }, ctx?: AuthContext): Promise<string[]>;
+    }): Promise<string[]>;
 }
 
-export { WebSocketServer };
+export { WebSocketServer, type WebSocketServerOptions };

package/dist/net/websocket/WebSocketServer.js

@@ -1,38 +1,49 @@
 import "../../chunk-IZ2YBCUP.js";
 import { ErrorCodes, StatusError } from "../error.js";
+import { getAuthContext } from "../serverContext.js";
 import { denyAll } from "./AuthorizationProvider.js";
 class WebSocketServer {
+  rpc;
   transport;
   auth;
   /**
-   * Creates a new Patches WebSocket client instance.
+   * Creates a new Patches WebSocket server instance.
    *
-   * @param transport - The transport layer implementation that will be used for sending/receiving messages
+   * @param options - Configuration options including transport, rpc, and optional auth
    */
-  constructor(transport, rpcServer) {
+  constructor({ transport, rpc, auth = denyAll }) {
     this.transport = transport;
-    const { rpc, auth } = rpcServer;
-    this.auth = auth || denyAll;
+    this.rpc = rpc;
+    this.auth = auth;
     rpc.registerMethod("subscribe", this.subscribe.bind(this));
     rpc.registerMethod("unsubscribe", this.unsubscribe.bind(this));
-    rpc.onNotify(async (msg) => {
+    rpc.onNotify(async (msg, exceptConnectionId) => {
       if (!msg.params?.docId) return;
       const { docId } = msg.params;
       const msgString = JSON.stringify(msg);
       const clientIds = await this.transport.listSubscriptions(docId);
       clientIds.forEach((clientId) => {
-        this.transport.send(clientId, msgString);
+        if (clientId !== exceptConnectionId) {
+          this.transport.send(clientId, msgString);
+        }
       });
     });
   }
+  /**
+   * Process an incoming message from a client.
+   * Delegates to the RPC server for handling.
+   */
+  async processMessage(raw, ctx) {
+    return this.rpc.processMessage(raw, ctx);
+  }
   /**
    * Subscribes the client to one or more documents to receive real-time updates.
    * If a document has been deleted (tombstone exists), sends immediate docDeleted notification.
-   * @param connectionId - The ID of the connection making the request
    * @param params - The subscription parameters
    * @param params.ids - Document ID or IDs to subscribe to
    */
-  async subscribe(params, ctx) {
+  async subscribe(params) {
+    const ctx = getAuthContext();
     if (!ctx?.clientId) return [];
     const { ids } = params;
     const allIds = Array.isArray(ids) ? ids : [ids];
@@ -64,14 +75,14 @@ class WebSocketServer {
   }
   /**
    * Unsubscribes the client from one or more documents.
-   * @param connectionId - The ID of the connection making the request
    * @param params - The unsubscription parameters
    * @param params.ids - Document ID or IDs to unsubscribe from
    */
-  async unsubscribe(params, ctx) {
+  async unsubscribe(params) {
+    const ctx = getAuthContext();
     if (!ctx?.clientId) return [];
     const { ids } = params;
-    return this.transport.removeSubscription(ctx?.clientId, Array.isArray(ids) ? ids : [ids]);
+    return this.transport.removeSubscription(ctx.clientId, Array.isArray(ids) ? ids : [ids]);
   }
 }
 export {

package/dist/server/BranchManager.d.ts

@@ -0,0 +1,50 @@
+import { Branch, EditableBranchMetadata, BranchStatus, Change } from '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
+/**
+ * Interface for managing document branches.
+ * Implementations handle algorithm-specific branching and merging logic.
+ *
+ * A branch is a document that originates from another document at a specific point.
+ * Its first version represents the source document's state at the branch point.
+ * Branches allow parallel development with the ability to merge changes back.
+ */
+interface BranchManager {
+    /**
+     * Lists all branches for a document.
+     * @param docId - The source document ID.
+     * @returns Array of branch metadata.
+     */
+    listBranches(docId: string): Promise<Branch[]>;
+    /**
+     * Creates a new branch from a document.
+     * @param docId - The source document ID.
+     * @param atPoint - Algorithm-specific branching point (revision for OT, typically current rev for LWW).
+     * @param metadata - Optional branch metadata (name, custom fields).
+     * @returns The new branch document ID.
+     */
+    createBranch(docId: string, atPoint: number, metadata?: EditableBranchMetadata): Promise<string>;
+    /**
+     * Updates branch metadata.
+     * @param branchId - The branch document ID.
+     * @param metadata - The metadata fields to update.
+     */
+    updateBranch(branchId: string, metadata: EditableBranchMetadata): Promise<void>;
+    /**
+     * Closes a branch with the specified status.
+     * @param branchId - The branch document ID.
+     * @param status - The status to set (defaults to 'closed').
+     */
+    closeBranch(branchId: string, status?: Exclude<BranchStatus, 'open'>): Promise<void>;
+    /**
+     * Merges a branch back into its source document.
+     * Algorithm-specific: OT uses fast-forward or flattened merge, LWW uses timestamp resolution.
+     * @param branchId - The branch document ID to merge.
+     * @returns The changes applied to the source document.
+     */
+    mergeBranch(branchId: string): Promise<Change[]>;
+}
+
+export type { BranchManager };

package/dist/server/CompressedStoreBackend.d.ts

@@ -1,13 +1,17 @@
 import { OpsCompressor } from '../compression/index.js';
 import { Change, ListChangesOptions, VersionMetadata, EditableVersionMetadata, ListVersionsOptions, DocumentTombstone } from '../types.js';
-import { PatchesStoreBackend } from './types.js';
-import '../algorithms/shared/lz.js';
+import { OTStoreBackend, TombstoneStoreBackend } from './types.js';
+import '../compression/lz.js';
 import '../json-patch/types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 
 /**
- * Wraps a PatchesStoreBackend to transparently compress/decompress the ops field of Changes.
+ * Store backend type that supports OT operations and optionally tombstones.
+ */
+type CompressibleStore = OTStoreBackend & Partial<TombstoneStoreBackend>;
+/**
+ * Wraps an OTStoreBackend to transparently compress/decompress the ops field of Changes.
  * Compression happens before save and decompression happens after load.
  *
  * This allows backends with row-size limits to store larger changes by compressing the payload.
@@ -16,10 +20,10 @@ import '@dabble/delta';
  * import { base64Compressor } from '@dabble/patches/compression';
  * const backend = new CompressedStoreBackend(myStore, base64Compressor);
  */
-declare class CompressedStoreBackend implements PatchesStoreBackend {
+declare class CompressedStoreBackend implements OTStoreBackend, Partial<TombstoneStoreBackend> {
     private readonly store;
     private readonly compressor;
-    constructor(store: PatchesStoreBackend, compressor: OpsCompressor);
+    constructor(store: CompressibleStore, compressor: OpsCompressor);
     /**
      * Compresses a single change's ops field.
      */
@@ -30,11 +34,9 @@ declare class CompressedStoreBackend implements PatchesStoreBackend {
     private decompressChange;
     saveChanges(docId: string, changes: Change[]): Promise<void>;
     listChanges(docId: string, options: ListChangesOptions): Promise<Change[]>;
-    createVersion(docId: string, metadata: VersionMetadata, state: any, changes: Change[]): Promise<void>;
+    createVersion(docId: string, metadata: VersionMetadata, state: any, changes?: Change[]): Promise<void>;
     appendVersionChanges(docId: string, versionId: string, changes: Change[], newEndedAt: number, newRev: number, newState: any): Promise<void>;
     loadVersionChanges(docId: string, versionId: string): Promise<Change[]>;
-    get loadLastVersionState(): PatchesStoreBackend['loadLastVersionState'];
-    get saveLastVersionState(): PatchesStoreBackend['saveLastVersionState'];
     updateVersion(docId: string, versionId: string, metadata: EditableVersionMetadata): Promise<void>;
     listVersions(docId: string, options: ListVersionsOptions): Promise<VersionMetadata[]>;
     loadVersionState(docId: string, versionId: string): Promise<any | undefined>;

package/dist/server/CompressedStoreBackend.js

@@ -36,12 +36,12 @@ class CompressedStoreBackend {
   }
   // === Version Operations (compress changes and state ops) ===
   async createVersion(docId, metadata, state, changes) {
-    const compressedChanges = changes.map((c) => this.compressChange(c));
+    const compressedChanges = changes?.map((c) => this.compressChange(c));
     return this.store.createVersion(docId, metadata, state, compressedChanges);
   }
   async appendVersionChanges(docId, versionId, changes, newEndedAt, newRev, newState) {
     const compressedChanges = changes.map((c) => this.compressChange(c));
-    return this.store.appendVersionChanges(
+    return this.store.appendVersionChanges?.(
       docId,
       versionId,
       compressedChanges,
@@ -51,16 +51,10 @@ class CompressedStoreBackend {
     );
   }
   async loadVersionChanges(docId, versionId) {
-    const stored = await this.store.loadVersionChanges(docId, versionId);
-    return stored.map((s) => this.decompressChange(s));
+    const stored = await this.store.loadVersionChanges?.(docId, versionId);
+    return stored?.map((s) => this.decompressChange(s)) ?? [];
   }
   // === Pass-through Operations (no compression needed) ===
-  get loadLastVersionState() {
-    return this.store.loadLastVersionState?.bind(this.store);
-  }
-  get saveLastVersionState() {
-    return this.store.saveLastVersionState?.bind(this.store);
-  }
   async updateVersion(docId, versionId, metadata) {
     return this.store.updateVersion(docId, versionId, metadata);
   }
@@ -74,13 +68,13 @@ class CompressedStoreBackend {
     return this.store.deleteDoc(docId);
   }
   async createTombstone(tombstone) {
-    return this.store.createTombstone(tombstone);
+    return this.store.createTombstone?.(tombstone);
   }
   async getTombstone(docId) {
-    return this.store.getTombstone(docId);
+    return this.store.getTombstone?.(docId);
   }
   async removeTombstone(docId) {
-    return this.store.removeTombstone(docId);
+    return this.store.removeTombstone?.(docId);
   }
 }
 export {

package/dist/server/LWWBranchManager.d.ts

@@ -0,0 +1,82 @@
+import { ApiDefinition } from '../net/protocol/JSONRPCServer.js';
+import { Branch, EditableBranchMetadata, BranchStatus, Change } from '../types.js';
+import { BranchManager } from './BranchManager.js';
+import { LWWServer } from './LWWServer.js';
+import { LWWStoreBackend, BranchingStoreBackend } from './types.js';
+import '../event-signal.js';
+import '../net/websocket/AuthorizationProvider.js';
+import '../json-patch/types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../net/protocol/types.js';
+import './PatchesServer.js';
+
+/**
+ * Combined store type for LWW branch management.
+ * Requires LWW ops operations and branch metadata operations.
+ */
+type LWWBranchStore = LWWStoreBackend & BranchingStoreBackend;
+/**
+ * LWW-specific branch manager implementation.
+ *
+ * Manages branches for documents using Last-Write-Wins semantics:
+ * - Creates branches from the current document state (copies ops with timestamps)
+ * - Merges by applying branch ops changes to source; timestamps resolve conflicts automatically
+ * - No transformation needed - LWW conflicts resolve deterministically by timestamp
+ *
+ * LWW branching is simpler than OT because:
+ * - Timestamps are immutable and survive branching/merging
+ * - Conflict resolution is deterministic (later timestamp wins)
+ * - Merging is idempotent - merge the same ops multiple times, get the same result
+ */
+declare class LWWBranchManager implements BranchManager {
+    private readonly store;
+    private readonly lwwServer;
+    static api: ApiDefinition;
+    constructor(store: LWWBranchStore, lwwServer: LWWServer);
+    /**
+     * Lists all branches for a document.
+     * @param docId - The source document ID.
+     * @returns Array of branch metadata.
+     */
+    listBranches(docId: string): Promise<Branch[]>;
+    /**
+     * Creates a new branch from a document's current state.
+     *
+     * Note: Unlike OT, LWW cannot access historical states, so branches
+     * always start from the current state. The `atPoint` parameter is
+     * recorded for tracking purposes.
+     *
+     * @param docId - The source document ID.
+     * @param atPoint - The revision number (recorded for tracking).
+     * @param metadata - Optional branch metadata.
+     * @returns The new branch document ID.
+     */
+    createBranch(docId: string, atPoint: number, metadata?: EditableBranchMetadata): Promise<string>;
+    /**
+     * Updates branch metadata.
+     * @param branchId - The branch document ID.
+     * @param metadata - The metadata ops to update.
+     */
+    updateBranch(branchId: string, metadata: EditableBranchMetadata): Promise<void>;
+    /**
+     * Closes a branch with the specified status.
+     * @param branchId - The branch document ID.
+     * @param status - The status to set (defaults to 'closed').
+     */
+    closeBranch(branchId: string, status?: Exclude<BranchStatus, 'open'>): Promise<void>;
+    /**
+     * Merges a branch back into its source document.
+     *
+     * LWW merge strategy:
+     * 1. Get all ops changes made on the branch since it was created
+     * 2. Apply those changes to the source document
+     * 3. Timestamps automatically resolve any conflicts (later wins)
+     *
+     * @param branchId - The branch document ID.
+     * @returns The changes applied to the source document.
+     */
+    mergeBranch(branchId: string): Promise<Change[]>;
+}
+
+export { LWWBranchManager };

package/dist/server/LWWBranchManager.js

@@ -0,0 +1,99 @@
+import "../chunk-IZ2YBCUP.js";
+import {
+  assertBranchMetadata,
+  assertBranchOpenForMerge,
+  assertNotABranch,
+  branchManagerApi,
+  createBranchRecord,
+  generateBranchId,
+  wrapMergeCommit
+} from "./branchUtils.js";
+class LWWBranchManager {
+  constructor(store, lwwServer) {
+    this.store = store;
+    this.lwwServer = lwwServer;
+  }
+  static api = branchManagerApi;
+  /**
+   * Lists all branches for a document.
+   * @param docId - The source document ID.
+   * @returns Array of branch metadata.
+   */
+  async listBranches(docId) {
+    return await this.store.listBranches(docId);
+  }
+  /**
+   * Creates a new branch from a document's current state.
+   *
+   * Note: Unlike OT, LWW cannot access historical states, so branches
+   * always start from the current state. The `atPoint` parameter is
+   * recorded for tracking purposes.
+   *
+   * @param docId - The source document ID.
+   * @param atPoint - The revision number (recorded for tracking).
+   * @param metadata - Optional branch metadata.
+   * @returns The new branch document ID.
+   */
+  async createBranch(docId, atPoint, metadata) {
+    await assertNotABranch(this.store, docId);
+    const doc = await this.lwwServer.getDoc(docId);
+    const ops = await this.store.listOps(docId);
+    const branchDocId = await generateBranchId(this.store, docId);
+    await this.store.saveSnapshot(branchDocId, doc.state, doc.rev);
+    if (ops.length > 0) {
+      await this.store.saveOps(branchDocId, ops);
+    }
+    const branch = createBranchRecord(branchDocId, docId, atPoint, metadata);
+    await this.store.createBranch(branch);
+    return branchDocId;
+  }
+  /**
+   * Updates branch metadata.
+   * @param branchId - The branch document ID.
+   * @param metadata - The metadata ops to update.
+   */
+  async updateBranch(branchId, metadata) {
+    assertBranchMetadata(metadata);
+    await this.store.updateBranch(branchId, metadata);
+  }
+  /**
+   * Closes a branch with the specified status.
+   * @param branchId - The branch document ID.
+   * @param status - The status to set (defaults to 'closed').
+   */
+  async closeBranch(branchId, status = "closed") {
+    await this.store.updateBranch(branchId, { status });
+  }
+  /**
+   * Merges a branch back into its source document.
+   *
+   * LWW merge strategy:
+   * 1. Get all ops changes made on the branch since it was created
+   * 2. Apply those changes to the source document
+   * 3. Timestamps automatically resolve any conflicts (later wins)
+   *
+   * @param branchId - The branch document ID.
+   * @returns The changes applied to the source document.
+   */
+  async mergeBranch(branchId) {
+    const branch = await this.store.loadBranch(branchId);
+    assertBranchOpenForMerge(branch, branchId);
+    const sourceDocId = branch.docId;
+    const branchChanges = await this.lwwServer.getChangesSince(branchId, branch.branchedAtRev);
+    if (branchChanges.length === 0) {
+      console.log(`Branch ${branchId} has no changes to merge.`);
+      await this.closeBranch(branchId, "merged");
+      return [];
+    }
+    const committedChanges = await wrapMergeCommit(
+      branchId,
+      sourceDocId,
+      () => this.lwwServer.commitChanges(sourceDocId, branchChanges)
+    );
+    await this.closeBranch(branchId, "merged");
+    return committedChanges;
+  }
+}
+export {
+  LWWBranchManager
+};

package/dist/server/LWWMemoryStoreBackend.d.ts

@@ -0,0 +1,78 @@
+import { JSONPatchOp } from '../json-patch/types.js';
+import { DocumentTombstone, VersionMetadata, Change, ListVersionsOptions, EditableVersionMetadata, Branch } from '../types.js';
+import { LWWStoreBackend, VersioningStoreBackend, TombstoneStoreBackend, BranchingStoreBackend, ListFieldsOptions } from './types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+
+interface DocData {
+    snapshot: {
+        state: any;
+        rev: number;
+    } | null;
+    ops: JSONPatchOp[];
+    rev: number;
+}
+interface VersionData {
+    metadata: VersionMetadata;
+    state: any;
+}
+/**
+ * In-memory implementation of LWWStoreBackend for testing.
+ * Also implements TombstoneStoreBackend, VersioningStoreBackend, and BranchingStoreBackend
+ * for comprehensive testing of all LWW functionality.
+ *
+ * @example
+ * ```typescript
+ * import { LWWServer } from '@dabble/patches/server';
+ * import { LWWMemoryStoreBackend } from '@dabble/patches/server';
+ *
+ * const store = new LWWMemoryStoreBackend();
+ * const server = new LWWServer(store);
+ * ```
+ */
+declare class LWWMemoryStoreBackend implements LWWStoreBackend, VersioningStoreBackend, TombstoneStoreBackend, BranchingStoreBackend {
+    private docs;
+    private tombstones;
+    private versions;
+    private branches;
+    private getOrCreateDoc;
+    getCurrentRev(docId: string): Promise<number>;
+    getSnapshot(docId: string): Promise<{
+        state: any;
+        rev: number;
+    } | null>;
+    saveSnapshot(docId: string, state: any, rev: number): Promise<void>;
+    saveOps(docId: string, newOps: JSONPatchOp[], pathsToDelete?: string[]): Promise<number>;
+    listOps(docId: string, options?: ListFieldsOptions): Promise<JSONPatchOp[]>;
+    deleteDoc(docId: string): Promise<void>;
+    createTombstone(tombstone: DocumentTombstone): Promise<void>;
+    getTombstone(docId: string): Promise<DocumentTombstone | undefined>;
+    removeTombstone(docId: string): Promise<void>;
+    createVersion(docId: string, metadata: VersionMetadata, state: any, _changes?: Change[]): Promise<void>;
+    listVersions(docId: string, options?: ListVersionsOptions): Promise<VersionMetadata[]>;
+    loadVersionState(docId: string, versionId: string): Promise<any | undefined>;
+    updateVersion(docId: string, versionId: string, metadata: EditableVersionMetadata): Promise<void>;
+    listBranches(docId: string): Promise<Branch[]>;
+    loadBranch(branchId: string): Promise<Branch | null>;
+    createBranch(branch: Branch): Promise<void>;
+    updateBranch(branchId: string, updates: Partial<Pick<Branch, 'status' | 'name' | 'metadata'>>): Promise<void>;
+    closeBranch(branchId: string): Promise<void>;
+    /**
+     * Clears all data from the store. Useful for test cleanup.
+     */
+    clear(): void;
+    /**
+     * Gets the raw document data for inspection in tests.
+     */
+    getDocData(docId: string): DocData | undefined;
+    /**
+     * Gets the versions for a document for inspection in tests.
+     */
+    getVersions(docId: string): VersionData[] | undefined;
+    /**
+     * Gets all branches for inspection in tests.
+     */
+    getBranches(): Map<string, Branch>;
+}
+
+export { LWWMemoryStoreBackend };