@dabble/patches 0.7.6 → 0.7.7

package/dist/algorithms/lww/consolidateOps.js

@@ -1,5 +1,6 @@
 import "../../chunk-IZ2YBCUP.js";
 import { applyBitmask, combineBitmasks } from "../../json-patch/ops/bitmask.js";
+import { isEmptyContainer } from "../../json-patch/utils/softWrites.js";
 const combinableOps = {
   "@inc": {
     apply: (a, b) => a + b,
@@ -33,6 +34,9 @@ function consolidateFieldOp(existing, incoming) {
     }
     return { ...incoming, op, value };
   }
+  if (isSoftOp(incoming)) {
+    return null;
+  }
   if (isExistingNewer(existing.ts, incoming.ts)) {
     return null;
   }
@@ -58,6 +62,19 @@ function consolidateOps(existingOps, newOps) {
         opsToSave.push(consolidated);
       }
     } else {
+      if (isSoftOp(newOp)) {
+        let dataExists = false;
+        for (const existingPath of existingByPath.keys()) {
+          if (existingPath.startsWith(newOp.path + "/")) {
+            dataExists = true;
+            break;
+          }
+        }
+        if (!dataExists) {
+          dataExists = pathExistsInParentOp(newOp.path, existingByPath);
+        }
+        if (dataExists) continue;
+      }
       for (const existingPath of existingByPath.keys()) {
         if (existingPath.startsWith(newOp.path + "/")) {
           pathsToDelete.add(existingPath);
@@ -92,6 +109,30 @@ function parentFixes(path, existing) {
   }
   return pathsToDelete;
 }
+function pathExistsInParentOp(path, existingByPath) {
+  let parent = path;
+  while (parent.lastIndexOf("/") > 0) {
+    parent = parent.substring(0, parent.lastIndexOf("/"));
+    const parentOp = existingByPath.get(parent);
+    if (parentOp && isObject(parentOp.value)) {
+      const remainingKeys = path.substring(parent.length + 1).split("/");
+      let current = parentOp.value;
+      let found = true;
+      for (const key of remainingKeys) {
+        if (!isObject(current) || !(key in current)) {
+          found = false;
+          break;
+        }
+        current = current[key];
+      }
+      if (found) return true;
+    }
+  }
+  return false;
+}
+function isSoftOp(op) {
+  return op.soft === true || op.op === "add" && isEmptyContainer(op.value);
+}
 function isObject(value) {
   return value !== null && typeof value === "object";
 }

package/dist/client/Patches.d.ts

@@ -7,6 +7,15 @@ import { AlgorithmName } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 
+/**
+ * Options for opening a document, passed through to `patches.openDoc()`.
+ */
+interface OpenDocOptions {
+    /** Optional metadata to attach to the document. */
+    metadata?: Record<string, any>;
+    /** Override the algorithm for this document (defaults to the Patches instance default). */
+    algorithm?: AlgorithmName;
+}
 /**
  * Options for creating a Patches instance.
  * Provides algorithms map and optional default algorithm.
@@ -85,10 +94,7 @@ declare class Patches {
      * @param opts - Optional metadata and algorithm override.
      * @returns The opened PatchesDoc instance.
      */
-    openDoc<T extends object>(docId: string, opts?: {
-        metadata?: Record<string, any>;
-        algorithm?: AlgorithmName;
-    }): Promise<PatchesDoc<T>>;
+    openDoc<T extends object>(docId: string, opts?: OpenDocOptions): Promise<PatchesDoc<T>>;
     /**
      * Closes an open document by ID, removing listeners and optionally untracking it.
      * @param docId - The document ID to close.
@@ -122,4 +128,4 @@ declare class Patches {
     protected _handleDocChange<T extends object>(docId: string, ops: JSONPatchOp[], doc: PatchesDoc<T>, algorithm: ClientAlgorithm, metadata: Record<string, any>): Promise<void>;
 }
 
-export { Patches, type PatchesOptions };
+export { type OpenDocOptions, Patches, type PatchesOptions };

package/dist/client/index.d.ts

@@ -9,7 +9,7 @@ export { LWWDoc } from './LWWDoc.js';
 export { LWWAlgorithm } from './LWWAlgorithm.js';
 export { LWWBatcher } from './LWWBatcher.js';
 export { OTAlgorithm } from './OTAlgorithm.js';
-export { Patches, PatchesOptions } from './Patches.js';
+export { OpenDocOptions, Patches, PatchesOptions } from './Patches.js';
 export { PatchesHistoryClient } from './PatchesHistoryClient.js';
 export { AlgorithmName, PatchesStore, TrackedDoc } from './PatchesStore.js';
 export { OTClientStore } from './OTClientStore.js';

package/dist/index.d.ts

@@ -10,7 +10,7 @@ export { LWWDoc } from './client/LWWDoc.js';
 export { LWWAlgorithm } from './client/LWWAlgorithm.js';
 export { LWWBatcher } from './client/LWWBatcher.js';
 export { OTAlgorithm } from './client/OTAlgorithm.js';
-export { Patches, PatchesOptions } from './client/Patches.js';
+export { OpenDocOptions, Patches, PatchesOptions } from './client/Patches.js';
 export { PatchesHistoryClient } from './client/PatchesHistoryClient.js';
 export { AlgorithmName, PatchesStore, TrackedDoc } from './client/PatchesStore.js';
 export { OTClientStore } from './client/OTClientStore.js';

package/dist/shared/doc-manager.d.ts

@@ -1,4 +1,4 @@
-import { Patches } from '../client/Patches.js';
+import { Patches, OpenDocOptions } from '../client/Patches.js';
 import { a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
 import '../event-signal.js';
 import '../json-patch/types.js';
@@ -31,7 +31,7 @@ declare class DocManager {
      * @param docId - Document ID to open
      * @returns Promise resolving to PatchesDoc instance
      */
-    openDoc<T extends object>(patches: Patches, docId: string): Promise<PatchesDoc<T>>;
+    openDoc<T extends object>(patches: Patches, docId: string, opts?: OpenDocOptions): Promise<PatchesDoc<T>>;
     /**
      * Closes a document with reference counting.
      *

package/dist/shared/doc-manager.js

@@ -13,7 +13,7 @@ class DocManager {
    * @param docId - Document ID to open
    * @returns Promise resolving to PatchesDoc instance
    */
-  async openDoc(patches, docId) {
+  async openDoc(patches, docId, opts) {
     const currentCount = this.refCounts.get(docId) || 0;
     if (currentCount === 0 && this.pendingOps.has(docId)) {
       const doc = await this.pendingOps.get(docId);
@@ -28,7 +28,7 @@ class DocManager {
       }
       return doc;
     }
-    const openPromise = patches.openDoc(docId);
+    const openPromise = patches.openDoc(docId, opts);
     this.pendingOps.set(docId, openPromise);
     try {
       const doc = await openPromise;

package/dist/solid/primitives.d.ts

@@ -1,15 +1,18 @@
 import { Accessor } from 'solid-js';
+import { OpenDocOptions } from '../client/Patches.js';
 import { a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
 import { JSONPatch } from '../json-patch/JSONPatch.js';
 import { ChangeMutator } from '../types.js';
 import '../event-signal.js';
 import '../json-patch/types.js';
+import '../client/ClientAlgorithm.js';
+import '../client/PatchesStore.js';
 import '@dabble/delta';
 
 /**
  * Options for usePatchesDoc primitive (eager mode with docId).
  */
-interface UsePatchesDocOptions {
+interface UsePatchesDocOptions extends OpenDocOptions {
     /**
      * Controls document lifecycle management on cleanup.
      *
@@ -89,8 +92,9 @@ interface UsePatchesDocLazyReturn<T extends object> extends UsePatchesDocReturn<
      * Open a document by path. Closes any previously loaded document first.
      *
      * @param docPath - The document path to open
+     * @param options - Optional algorithm and metadata overrides
      */
-    load: (docPath: string) => Promise<void>;
+    load: (docPath: string, options?: OpenDocOptions) => Promise<void>;
     /**
      * Close the current document, unsubscribe, and reset all state.
      * Calls `patches.closeDoc()` but does not untrack — tracking is managed separately.
@@ -102,8 +106,9 @@ interface UsePatchesDocLazyReturn<T extends object> extends UsePatchesDocReturn<
      *
      * @param docPath - The document path to create
      * @param initialState - Initial state object or JSONPatch to apply
+     * @param options - Optional algorithm and metadata overrides
      */
-    create: (docPath: string, initialState: T | JSONPatch) => Promise<void>;
+    create: (docPath: string, initialState: T | JSONPatch, options?: OpenDocOptions) => Promise<void>;
 }
 /**
  * Solid primitive for reactive Patches document state.
@@ -185,7 +190,7 @@ type MaybeAccessor<T> = T | Accessor<T>;
 /**
  * Props for the Provider component returned by createPatchesDoc.
  */
-interface PatchesDocProviderProps {
+interface PatchesDocProviderProps extends OpenDocOptions {
     docId: MaybeAccessor<string>;
     autoClose?: boolean | 'untrack';
     children: any;

package/dist/solid/primitives.js

@@ -10,47 +10,87 @@ import {
 import { JSONPatch } from "../json-patch/JSONPatch.js";
 import { usePatchesContext } from "./context.js";
 import { getDocManager } from "./doc-manager.js";
-function usePatchesDoc(docIdOrOptions, options) {
-  if (typeof docIdOrOptions === "string" || typeof docIdOrOptions === "function") {
-    return _usePatchesDocEager(docIdOrOptions, options ?? {});
-  }
-  return _usePatchesDocLazy(docIdOrOptions ?? {});
-}
-function _usePatchesDocEager(docId, options) {
-  const { patches } = usePatchesContext();
-  const autoClose = options.autoClose ?? false;
-  const shouldUntrack = autoClose === "untrack";
+function createDocReactiveState(options) {
+  const { initialLoading = true, transformState, changeBehavior } = options;
   const [doc, setDoc] = createSignal(void 0);
   const [data, setData] = createSignal(void 0);
-  const [loading, setLoading] = createSignal(true);
+  const [loading, setLoading] = createSignal(initialLoading);
   const [error, setError] = createSignal(null);
   const [rev, setRev] = createSignal(0);
   const [hasPending, setHasPending] = createSignal(false);
-  const manager = getDocManager(patches);
-  const docIdAccessor = toAccessor(docId);
   function setupDoc(patchesDoc) {
     setDoc(patchesDoc);
     const unsubState = patchesDoc.subscribe((state) => {
+      if (transformState && state) {
+        state = transformState(state, patchesDoc);
+      }
       setData(() => state);
       setRev(patchesDoc.committedRev);
       setHasPending(patchesDoc.hasPending);
     });
-    onCleanup(() => unsubState());
     const unsubSync = patchesDoc.onSyncing((syncState) => {
       setLoading(syncState === "initial" || syncState === "updating");
       setError(syncState instanceof Error ? syncState : null);
     });
-    onCleanup(() => unsubSync());
     setLoading(patchesDoc.syncing !== null);
+    return () => {
+      unsubState();
+      unsubSync();
+    };
   }
+  function resetSignals() {
+    setDoc(void 0);
+    setData(void 0);
+    setLoading(false);
+    setError(null);
+    setRev(0);
+    setHasPending(false);
+  }
+  function change(mutator) {
+    if (changeBehavior === "throw") {
+      const currentDoc = doc();
+      if (!currentDoc) {
+        throw new Error("Cannot make changes: document not loaded yet");
+      }
+      currentDoc.change(mutator);
+    } else {
+      doc()?.change(mutator);
+    }
+  }
+  const baseReturn = {
+    data,
+    loading,
+    error,
+    rev,
+    hasPending,
+    change,
+    doc
+  };
+  return { doc, setDoc, data, setData, loading, setLoading, error, setError, rev, setRev, hasPending, setHasPending, setupDoc, resetSignals, change, baseReturn };
+}
+function usePatchesDoc(docIdOrOptions, options) {
+  if (typeof docIdOrOptions === "string" || typeof docIdOrOptions === "function") {
+    return _usePatchesDocEager(docIdOrOptions, options ?? {});
+  }
+  return _usePatchesDocLazy(docIdOrOptions ?? {});
+}
+function _usePatchesDocEager(docId, options) {
+  const { patches } = usePatchesContext();
+  const { autoClose = false, algorithm, metadata } = options;
+  const shouldUntrack = autoClose === "untrack";
+  const openDocOpts = { algorithm, metadata };
+  const manager = getDocManager(patches);
+  const { setupDoc, setError, setLoading, baseReturn } = createDocReactiveState({ changeBehavior: "throw" });
+  const docIdAccessor = toAccessor(docId);
   if (autoClose) {
     const [docResource] = createResource(docIdAccessor, async (id) => {
-      return await manager.openDoc(patches, id);
+      return await manager.openDoc(patches, id, openDocOpts);
     });
     createEffect(() => {
       const loadedDoc = docResource();
       if (loadedDoc) {
-        setupDoc(loadedDoc);
+        const unsub = setupDoc(loadedDoc);
+        onCleanup(() => unsub());
       }
       const resourceError = docResource.error;
       if (resourceError) {
@@ -72,75 +112,31 @@ function _usePatchesDocEager(docId, options) {
         );
       }
       manager.incrementRefCount(id);
-      setupDoc(patchesDoc);
+      const unsub = setupDoc(patchesDoc);
       onCleanup(() => {
+        unsub();
         manager.decrementRefCount(id);
       });
     });
   }
-  function change(mutator) {
-    const currentDoc = doc();
-    if (!currentDoc) {
-      throw new Error("Cannot make changes: document not loaded yet");
-    }
-    currentDoc.change(mutator);
-  }
-  return {
-    data,
-    loading,
-    error,
-    rev,
-    hasPending,
-    change,
-    doc
-  };
+  return baseReturn;
 }
 function _usePatchesDocLazy(options) {
   const { patches } = usePatchesContext();
   const { idProp } = options;
-  let currentDoc = null;
+  const { setupDoc, resetSignals, setError, setLoading, baseReturn } = createDocReactiveState({
+    initialLoading: false,
+    changeBehavior: "noop",
+    transformState: idProp ? (state, patchesDoc) => ({ ...state, [idProp]: patchesDoc.id }) : void 0
+  });
   let unsubscribe = null;
   const [path, setPath] = createSignal(null);
-  const [doc, setDoc] = createSignal(void 0);
-  const [data, setData] = createSignal(void 0);
-  const [loading, setLoading] = createSignal(false);
-  const [error, setError] = createSignal(null);
-  const [rev, setRev] = createSignal(0);
-  const [hasPending, setHasPending] = createSignal(false);
-  function setupDoc(patchesDoc) {
-    currentDoc = patchesDoc;
-    setDoc(patchesDoc);
-    unsubscribe = patchesDoc.subscribe((state) => {
-      if (state && idProp && currentDoc) {
-        state = { ...state, [idProp]: currentDoc.id };
-      }
-      setData(() => state);
-      setRev(patchesDoc.committedRev);
-      setHasPending(patchesDoc.hasPending);
-    });
-    const unsubSync = patchesDoc.onSyncing((syncState) => {
-      setLoading(syncState === "initial" || syncState === "updating");
-      setError(syncState instanceof Error ? syncState : null);
-    });
-    const origUnsub = unsubscribe;
-    unsubscribe = () => {
-      origUnsub();
-      unsubSync();
-    };
-    setLoading(patchesDoc.syncing !== null);
-  }
   function teardown() {
     unsubscribe?.();
     unsubscribe = null;
-    currentDoc = null;
-    setDoc(void 0);
-    setData(void 0);
-    setLoading(false);
-    setError(null);
-    setRev(0);
-    setHasPending(false);
+    resetSignals();
   }
-  async function load(docPath) {
+  async function load(docPath, options2) {
     if (path()) {
       const prevPath = path();
       teardown();
@@ -148,8 +144,8 @@ function _usePatchesDocLazy(options) {
     }
     setPath(docPath);
     try {
-      const patchesDoc = await patches.openDoc(docPath);
-      setupDoc(patchesDoc);
+      const patchesDoc = await patches.openDoc(docPath, options2);
+      unsubscribe = setupDoc(patchesDoc);
     } catch (err) {
       setError(err);
       setLoading(false);
@@ -163,8 +159,8 @@ function _usePatchesDocLazy(options) {
       await patches.closeDoc(prevPath);
     }
   }
-  async function create(docPath, initialState) {
-    const newDoc = await patches.openDoc(docPath);
+  async function create(docPath, initialState, options2) {
+    const newDoc = await patches.openDoc(docPath, options2);
     newDoc.change((patch, root) => {
       if (initialState instanceof JSONPatch) {
         patch.ops = initialState.ops;
@@ -176,22 +172,7 @@ function _usePatchesDocLazy(options) {
     });
     await patches.closeDoc(docPath);
   }
-  function change(mutator) {
-    currentDoc?.change(mutator);
-  }
-  return {
-    data,
-    loading,
-    error,
-    rev,
-    hasPending,
-    change,
-    doc,
-    path,
-    load,
-    close,
-    create
-  };
+  return { ...baseReturn, path, load, close, create };
 }
 function usePatchesSync() {
   const { sync } = usePatchesContext();
@@ -225,36 +206,18 @@ function createPatchesDoc(name) {
     const manager = getDocManager(patches);
     const autoClose = props.autoClose ?? false;
     const shouldUntrack = autoClose === "untrack";
-    const [doc, setDoc] = createSignal(void 0);
-    const [data, setData] = createSignal(void 0);
-    const [loading, setLoading] = createSignal(true);
-    const [error, setError] = createSignal(null);
-    const [rev, setRev] = createSignal(0);
-    const [hasPending, setHasPending] = createSignal(false);
-    function setupDoc(patchesDoc) {
-      setDoc(patchesDoc);
-      const unsubState = patchesDoc.subscribe((state) => {
-        setData(() => state);
-        setRev(patchesDoc.committedRev);
-        setHasPending(patchesDoc.hasPending);
-      });
-      onCleanup(() => unsubState());
-      const unsubSync = patchesDoc.onSyncing((syncState) => {
-        setLoading(syncState === "initial" || syncState === "updating");
-        setError(syncState instanceof Error ? syncState : null);
-      });
-      onCleanup(() => unsubSync());
-      setLoading(patchesDoc.syncing !== null);
-    }
+    const openDocOpts = { algorithm: props.algorithm, metadata: props.metadata };
+    const { setupDoc, setError, setLoading, baseReturn } = createDocReactiveState({ changeBehavior: "throw" });
     const docIdAccessor = toAccessor(props.docId);
     if (autoClose) {
       const [docResource] = createResource(docIdAccessor, async (id) => {
-        return await manager.openDoc(patches, id);
+        return await manager.openDoc(patches, id, openDocOpts);
       });
       createEffect(() => {
         const loadedDoc = docResource();
         if (loadedDoc) {
-          setupDoc(loadedDoc);
+          const unsub = setupDoc(loadedDoc);
+          onCleanup(() => unsub());
         }
         const resourceError = docResource.error;
         if (resourceError) {
@@ -286,7 +249,8 @@ function createPatchesDoc(name) {
           );
         }
         manager.incrementRefCount(id);
-        setupDoc(patchesDoc);
+        const unsub = setupDoc(patchesDoc);
+        onCleanup(() => unsub());
         return id;
       });
       onCleanup(() => {
@@ -294,23 +258,7 @@ function createPatchesDoc(name) {
         manager.decrementRefCount(id);
       });
     }
-    function change(mutator) {
-      const currentDoc = doc();
-      if (!currentDoc) {
-        throw new Error("Cannot make changes: document not loaded yet");
-      }
-      currentDoc.change(mutator);
-    }
-    const value = {
-      data,
-      loading,
-      error,
-      rev,
-      hasPending,
-      change,
-      doc
-    };
-    return /* @__PURE__ */ React.createElement(Context.Provider, { value, children: props.children });
+    return /* @__PURE__ */ React.createElement(Context.Provider, { value: baseReturn, children: props.children });
   }
   function useDoc() {
     const context = useContext(Context);

package/dist/vue/composables.d.ts

@@ -1,15 +1,18 @@
 import { ShallowRef, Ref, MaybeRef } from 'vue';
+import { OpenDocOptions } from '../client/Patches.js';
 import { a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
 import { JSONPatch } from '../json-patch/JSONPatch.js';
 import { ChangeMutator } from '../types.js';
 import '../event-signal.js';
 import '../json-patch/types.js';
+import '../client/ClientAlgorithm.js';
+import '../client/PatchesStore.js';
 import '@dabble/delta';
 
 /**
  * Options for usePatchesDoc composable (eager mode with docId).
  */
-interface UsePatchesDocOptions {
+interface UsePatchesDocOptions extends OpenDocOptions {
     /**
      * Controls document lifecycle management on component unmount.
      *
@@ -89,8 +92,9 @@ interface UsePatchesDocLazyReturn<T extends object> extends UsePatchesDocReturn<
      * Open a document by path. Closes any previously loaded document first.
      *
      * @param docPath - The document path to open
+     * @param options - Optional algorithm and metadata overrides
      */
-    load: (docPath: string) => Promise<void>;
+    load: (docPath: string, options?: OpenDocOptions) => Promise<void>;
     /**
      * Close the current document, unsubscribe, and reset all state.
      * Calls `patches.closeDoc()` but does not untrack — tracking is managed separately.
@@ -102,8 +106,9 @@ interface UsePatchesDocLazyReturn<T extends object> extends UsePatchesDocReturn<
      *
      * @param docPath - The document path to create
      * @param initialState - Initial state object or JSONPatch to apply
+     * @param options - Optional algorithm and metadata overrides
      */
-    create: (docPath: string, initialState: T | JSONPatch) => Promise<void>;
+    create: (docPath: string, initialState: T | JSONPatch, options?: OpenDocOptions) => Promise<void>;
 }
 /**
  * Vue composable for reactive Patches document state.

package/dist/vue/composables.js

@@ -11,48 +11,86 @@ import {
 import { JSONPatch } from "../json-patch/JSONPatch.js";
 import { usePatchesContext } from "./provider.js";
 import { getDocManager } from "./doc-manager.js";
-function usePatchesDoc(docIdOrOptions, options) {
-  if (typeof docIdOrOptions === "string") {
-    return _usePatchesDocEager(docIdOrOptions, options ?? {});
-  }
-  return _usePatchesDocLazy(docIdOrOptions ?? {});
-}
-function _usePatchesDocEager(docId, options) {
-  const { patches } = usePatchesContext();
-  const { autoClose = false } = options;
-  const shouldUntrack = autoClose === "untrack";
+function createDocReactiveState(options) {
+  const { initialLoading = true, transformState, changeBehavior } = options;
   const doc = ref(void 0);
   const data = shallowRef(void 0);
-  const loading = ref(true);
+  const loading = ref(initialLoading);
   const error = ref(null);
   const rev = ref(0);
   const hasPending = ref(false);
-  const unsubscribers = [];
-  const manager = getDocManager(patches);
   function setupDoc(patchesDoc) {
     doc.value = patchesDoc;
     const unsubState = patchesDoc.subscribe((state) => {
+      if (transformState && state) {
+        state = transformState(state, patchesDoc);
+      }
       data.value = state;
       rev.value = patchesDoc.committedRev;
       hasPending.value = patchesDoc.hasPending;
     });
-    unsubscribers.push(unsubState);
     const unsubSync = patchesDoc.onSyncing((syncState) => {
       loading.value = syncState === "initial" || syncState === "updating";
       error.value = syncState instanceof Error ? syncState : null;
     });
-    unsubscribers.push(unsubSync);
     loading.value = patchesDoc.syncing !== null;
+    return () => {
+      unsubState();
+      unsubSync();
+    };
+  }
+  function resetRefs() {
+    doc.value = void 0;
+    data.value = void 0;
+    loading.value = false;
+    error.value = null;
+    rev.value = 0;
+    hasPending.value = false;
+  }
+  function change(mutator) {
+    if (changeBehavior === "throw") {
+      if (!doc.value) {
+        throw new Error("Cannot make changes: document not loaded yet");
+      }
+      doc.value.change(mutator);
+    } else {
+      doc.value?.change(mutator);
+    }
+  }
+  const baseReturn = {
+    data,
+    loading,
+    error,
+    rev,
+    hasPending,
+    change,
+    doc
+  };
+  return { doc, data, loading, error, rev, hasPending, setupDoc, resetRefs, change, baseReturn };
+}
+function usePatchesDoc(docIdOrOptions, options) {
+  if (typeof docIdOrOptions === "string") {
+    return _usePatchesDocEager(docIdOrOptions, options ?? {});
   }
+  return _usePatchesDocLazy(docIdOrOptions ?? {});
+}
+function _usePatchesDocEager(docId, options) {
+  const { patches } = usePatchesContext();
+  const { autoClose = false, algorithm, metadata } = options;
+  const shouldUntrack = autoClose === "untrack";
+  const openDocOpts = { algorithm, metadata };
+  const manager = getDocManager(patches);
+  const { setupDoc, baseReturn } = createDocReactiveState({ changeBehavior: "throw" });
+  let unsubscribe = null;
   if (autoClose) {
-    manager.openDoc(patches, docId).then((patchesDoc) => {
-      setupDoc(patchesDoc);
+    manager.openDoc(patches, docId, openDocOpts).then((patchesDoc) => {
+      unsubscribe = setupDoc(patchesDoc);
     }).catch((err) => {
-      error.value = err;
-      loading.value = false;
+      baseReturn.error.value = err;
+      baseReturn.loading.value = false;
     });
     onBeforeUnmount(() => {
-      unsubscribers.forEach((unsub) => unsub());
+      unsubscribe?.();
       manager.closeDoc(patches, docId, shouldUntrack);
     });
   } else {
@@ -63,74 +101,30 @@ function _usePatchesDocEager(docId, options) {
       );
     }
     manager.incrementRefCount(docId);
-    setupDoc(patchesDoc);
+    unsubscribe = setupDoc(patchesDoc);
     onBeforeUnmount(() => {
-      unsubscribers.forEach((unsub) => unsub());
+      unsubscribe?.();
       manager.decrementRefCount(docId);
     });
   }
-  function change(mutator) {
-    if (!doc.value) {
-      throw new Error("Cannot make changes: document not loaded yet");
-    }
-    doc.value.change(mutator);
-  }
-  return {
-    data,
-    loading,
-    error,
-    rev,
-    hasPending,
-    change,
-    doc
-  };
+  return baseReturn;
 }
 function _usePatchesDocLazy(options) {
   const { patches } = usePatchesContext();
   const { idProp } = options;
-  let currentDoc = null;
+  const { setupDoc, resetRefs, baseReturn } = createDocReactiveState({
+    initialLoading: false,
+    changeBehavior: "noop",
+    transformState: idProp ? (state, patchesDoc) => ({ ...state, [idProp]: patchesDoc.id }) : void 0
+  });
   let unsubscribe = null;
   const path = ref(null);
-  const doc = ref(void 0);
-  const data = shallowRef(void 0);
-  const loading = ref(false);
-  const error = ref(null);
-  const rev = ref(0);
-  const hasPending = ref(false);
-  function setupDoc(patchesDoc) {
-    currentDoc = patchesDoc;
-    doc.value = patchesDoc;
-    unsubscribe = patchesDoc.subscribe((state) => {
-      if (state && idProp && currentDoc) {
-        state = { ...state, [idProp]: currentDoc.id };
-      }
-      data.value = state;
-      rev.value = patchesDoc.committedRev;
-      hasPending.value = patchesDoc.hasPending;
-    });
-    const unsubSync = patchesDoc.onSyncing((syncState) => {
-      loading.value = syncState === "initial" || syncState === "updating";
-      error.value = syncState instanceof Error ? syncState : null;
-    });
-    const origUnsub = unsubscribe;
-    unsubscribe = () => {
-      origUnsub();
-      unsubSync();
-    };
-    loading.value = patchesDoc.syncing !== null;
-  }
   function teardown() {
     unsubscribe?.();
     unsubscribe = null;
-    currentDoc = null;
-    doc.value = void 0;
-    data.value = void 0;
-    loading.value = false;
-    error.value = null;
-    rev.value = 0;
-    hasPending.value = false;
+    resetRefs();
   }
-  async function load(docPath) {
+  async function load(docPath, options2) {
     if (path.value) {
       const prevPath = path.value;
       teardown();
@@ -138,11 +132,11 @@ function _usePatchesDocLazy(options) {
     }
     path.value = docPath;
     try {
-      const patchesDoc = await patches.openDoc(docPath);
-      setupDoc(patchesDoc);
+      const patchesDoc = await patches.openDoc(docPath, options2);
+      unsubscribe = setupDoc(patchesDoc);
     } catch (err) {
-      error.value = err;
-      loading.value = false;
+      baseReturn.error.value = err;
+      baseReturn.loading.value = false;
     }
   }
   async function close() {
@@ -153,8 +147,8 @@ function _usePatchesDocLazy(options) {
       await patches.closeDoc(prevPath);
     }
   }
-  async function create(docPath, initialState) {
-    const newDoc = await patches.openDoc(docPath);
+  async function create(docPath, initialState, options2) {
+    const newDoc = await patches.openDoc(docPath, options2);
     newDoc.change((patch, root) => {
       if (initialState instanceof JSONPatch) {
         patch.ops = initialState.ops;
@@ -166,22 +160,7 @@ function _usePatchesDocLazy(options) {
     });
     await patches.closeDoc(docPath);
   }
-  function change(mutator) {
-    currentDoc?.change(mutator);
-  }
-  return {
-    data,
-    loading,
-    error,
-    rev,
-    hasPending,
-    change,
-    doc,
-    path,
-    load,
-    close,
-    create
-  };
+  return { ...baseReturn, path, load, close, create };
 }
 function usePatchesSync() {
   const { sync } = usePatchesContext();
@@ -210,43 +189,24 @@ function createDocInjectionKey(name) {
 }
 function providePatchesDoc(name, docId, options = {}) {
   const { patches } = usePatchesContext();
-  const { autoClose = false } = options;
+  const { autoClose = false, algorithm, metadata } = options;
   const shouldUntrack = autoClose === "untrack";
+  const openDocOpts = { algorithm, metadata };
   const manager = getDocManager(patches);
-  const doc = ref(void 0);
-  const data = shallowRef(void 0);
-  const loading = ref(true);
-  const error = ref(null);
-  const rev = ref(0);
-  const hasPending = ref(false);
+  const { setupDoc, baseReturn } = createDocReactiveState({ changeBehavior: "throw" });
   const currentDocId = ref(unref(docId));
-  const unsubscribers = [];
-  function setupDoc(patchesDoc) {
-    unsubscribers.forEach((unsub) => unsub());
-    unsubscribers.length = 0;
-    doc.value = patchesDoc;
-    const unsubState = patchesDoc.subscribe((state) => {
-      data.value = state;
-      rev.value = patchesDoc.committedRev;
-      hasPending.value = patchesDoc.hasPending;
-    });
-    unsubscribers.push(unsubState);
-    const unsubSync = patchesDoc.onSyncing((syncState) => {
-      loading.value = syncState === "initial" || syncState === "updating";
-      error.value = syncState instanceof Error ? syncState : null;
-    });
-    unsubscribers.push(unsubSync);
-    loading.value = patchesDoc.syncing !== null;
-  }
+  let unsubscribe = null;
   async function initDoc(id) {
     currentDocId.value = id;
+    unsubscribe?.();
+    unsubscribe = null;
     if (autoClose) {
       try {
-        const patchesDoc = await manager.openDoc(patches, id);
-        setupDoc(patchesDoc);
+        const patchesDoc = await manager.openDoc(patches, id, openDocOpts);
+        unsubscribe = setupDoc(patchesDoc);
       } catch (err) {
-        error.value = err;
-        loading.value = false;
+        baseReturn.error.value = err;
+        baseReturn.loading.value = false;
       }
     } else {
       try {
@@ -257,36 +217,21 @@ function providePatchesDoc(name, docId, options = {}) {
           );
         }
         manager.incrementRefCount(id);
-        setupDoc(patchesDoc);
+        unsubscribe = setupDoc(patchesDoc);
       } catch (err) {
-        error.value = err;
-        loading.value = false;
+        baseReturn.error.value = err;
+        baseReturn.loading.value = false;
       }
     }
   }
-  function change(mutator) {
-    if (!doc.value) {
-      throw new Error("Cannot make changes: document not loaded yet");
-    }
-    doc.value.change(mutator);
-  }
-  const docReturn = {
-    data,
-    loading,
-    error,
-    rev,
-    hasPending,
-    change,
-    doc
-  };
   const key = createDocInjectionKey(name);
-  provide(key, docReturn);
+  provide(key, baseReturn);
   initDoc(unref(docId));
   if (typeof docId !== "string") {
     watch(docId, async (newDocId, oldDocId) => {
       if (newDocId === oldDocId) return;
-      unsubscribers.forEach((unsub) => unsub());
-      unsubscribers.length = 0;
+      unsubscribe?.();
+      unsubscribe = null;
       if (autoClose) {
         await manager.closeDoc(patches, oldDocId, shouldUntrack);
       } else {
@@ -296,14 +241,14 @@ function providePatchesDoc(name, docId, options = {}) {
     });
   }
   onBeforeUnmount(async () => {
-    unsubscribers.forEach((unsub) => unsub());
+    unsubscribe?.();
     if (autoClose) {
       await manager.closeDoc(patches, currentDocId.value, shouldUntrack);
     } else {
       manager.decrementRefCount(currentDocId.value);
     }
   });
-  return docReturn;
+  return baseReturn;
 }
 function useCurrentDoc(name) {
   const key = createDocInjectionKey(name);

package/dist/vue/managed-docs.d.ts

@@ -1,9 +1,18 @@
 import { Ref, ShallowRef } from 'vue';
+import { OpenDocOptions } from '../client/Patches.js';
+import '../event-signal.js';
+import '../json-patch/types.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../client/ClientAlgorithm.js';
+import '../BaseDoc-DkP3tUhT.js';
+import '../client/PatchesStore.js';
 
 /**
  * Options for useManagedDocs composable.
  */
-interface UseManagedDocsOptions {
+interface UseManagedDocsOptions extends OpenDocOptions {
     /**
      * Inject doc.id into state under this key on every state update.
      * Useful when the document ID is derived from the path but needed in the data.

package/dist/vue/managed-docs.js

@@ -5,7 +5,8 @@ import { areSetsEqual } from "./utils.js";
 const emptyPaths = /* @__PURE__ */ new Set();
 function useManagedDocs(pathsRef, initialData, reducer, options) {
   const { patches } = usePatchesContext();
-  const { idProp } = options ?? {};
+  const { idProp, algorithm, metadata } = options ?? {};
+  const openDocOpts = { algorithm, metadata };
   const data = shallowRef(initialData);
   const docs = /* @__PURE__ */ new Map();
   const unsubscribes = /* @__PURE__ */ new Map();
@@ -28,7 +29,7 @@ function useManagedDocs(pathsRef, initialData, reducer, options) {
   });
   async function openPath(path) {
     try {
-      const doc = await patches.openDoc(path);
+      const doc = await patches.openDoc(path, openDocOpts);
       if (currentPaths.has(path)) {
         docs.set(path, doc);
         let initialState = doc.state;

package/package.json

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