@dabble/patches 0.7.1 → 0.7.3

package/dist/solid/primitives.d.ts

@@ -1,27 +1,38 @@
 import { Accessor } from 'solid-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 '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 
 /**
- * Options for usePatchesDoc primitive.
+ * Options for usePatchesDoc primitive (eager mode with docId).
  */
 interface UsePatchesDocOptions {
     /**
-     * Whether to automatically open/close the document based on component lifecycle.
+     * Controls document lifecycle management on cleanup.
      *
-     * - `false` (default): Assumes doc is already open. Throws if not.
-     * - `true`: Opens doc on mount with ref counting, closes on cleanup.
+     * - `false` (default): Explicit mode. Assumes doc is already open. Throws if not.
+     * - `true`: Opens doc on mount with ref counting, closes on cleanup (doc stays tracked).
+     * - `'untrack'`: Opens doc on mount, closes AND untracks on cleanup (removes from sync).
      *
      * @default false
      */
-    autoClose?: boolean;
+    autoClose?: boolean | 'untrack';
 }
 /**
- * Return type for usePatchesDoc primitive.
+ * Options for usePatchesDoc primitive (lazy mode without docId).
+ */
+interface UsePatchesDocLazyOptions {
+    /**
+     * 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.
+     */
+    idProp?: string;
+}
+/**
+ * Return type for usePatchesDoc primitive (eager mode).
  */
 interface UsePatchesDocReturn<T extends object> {
     /**
@@ -65,57 +76,69 @@ interface UsePatchesDocReturn<T extends object> {
      */
     doc: Accessor<PatchesDoc<T> | undefined>;
 }
+/**
+ * Return type for usePatchesDoc primitive (lazy mode).
+ * Extends the eager return type with lifecycle management methods.
+ */
+interface UsePatchesDocLazyReturn<T extends object> extends UsePatchesDocReturn<T> {
+    /**
+     * Current document path. `null` when no document is loaded.
+     */
+    path: Accessor<string | null>;
+    /**
+     * Open a document by path. Closes any previously loaded document first.
+     *
+     * @param docPath - The document path to open
+     */
+    load: (docPath: string) => Promise<void>;
+    /**
+     * Close the current document, unsubscribe, and reset all state.
+     * Calls `patches.closeDoc()` but does not untrack — tracking is managed separately.
+     */
+    close: () => Promise<void>;
+    /**
+     * Create a new document: open it, set initial state, then close it.
+     * A one-shot operation that doesn't bind the document to this handle.
+     *
+     * @param docPath - The document path to create
+     * @param initialState - Initial state object or JSONPatch to apply
+     */
+    create: (docPath: string, initialState: T | JSONPatch) => Promise<void>;
+}
 /**
  * Solid primitive for reactive Patches document state.
  *
- * Provides reactive access to a Patches document with automatic lifecycle management.
- *
- * ## Explicit Lifecycle (default)
+ * ## Eager Mode (with docId)
  *
- * By default, assumes the document is already open and just adds Solid reactivity.
- * You control when documents are opened and closed.
+ * Provides reactive access to an already-open Patches document.
  *
  * @example
  * ```tsx
- * import { onMount, onCleanup } from 'solid-js';
- * import { usePatchesContext, usePatchesDoc } from '@dabble/patches/solid';
- *
- * function MyComponent(props) {
- *   const { patches } = usePatchesContext();
- *
- *   // You control lifecycle
- *   onMount(() => patches.openDoc(props.docId));
- *   onCleanup(() => patches.closeDoc(props.docId));
- *
- *   // Just adds reactivity
- *   // For static: usePatchesDoc('doc-123')
- *   // For reactive: usePatchesDoc(() => props.docId)
- *   const { data, loading, change } = usePatchesDoc(() => props.docId);
+ * // Explicit lifecycle — you control open/close
+ * const { data, loading, change } = usePatchesDoc(() => props.docId)
  *
- *   return <div>{data()?.title}</div>;
- * }
+ * // Auto lifecycle — opens on mount, closes on cleanup
+ * const { data, loading, change } = usePatchesDoc(() => props.docId, { autoClose: true })
  * ```
  *
- * ## Auto Lifecycle
+ * ## Lazy Mode (without docId)
  *
- * With `autoClose: true`, the primitive manages the document lifecycle with
- * reference counting. Safe to use in multiple components with the same docId.
+ * Returns a deferred handle with `load()`, `close()`, and `create()` methods.
+ * Does NOT register `onCleanup` — caller manages lifecycle.
  *
  * @example
  * ```tsx
- * // Opens on mount, closes on cleanup (ref-counted)
- * const { data, loading, change } = usePatchesDoc('doc-123', {
- *   autoClose: true
- * });
- * ```
+ * const { data, load, close, change, create } = usePatchesDoc<Project>()
  *
- * @param docId - Document ID (static string or accessor function)
- * @param options - Configuration options
- * @returns Reactive document state and utilities
- * @throws Error if Patches context not provided
- * @throws Error if doc not open in explicit mode
+ * // Later, when the user navigates:
+ * await load('projects/abc/content')
+ *
+ * // When leaving:
+ * await close()
+ * ```
  */
 declare function usePatchesDoc<T extends object>(docId: MaybeAccessor<string>, options?: UsePatchesDocOptions): UsePatchesDocReturn<T>;
+declare function usePatchesDoc<T extends object>(options?: UsePatchesDocLazyOptions): UsePatchesDocLazyReturn<T>;
 /**
  * Return type for usePatchesSync primitive.
  */
@@ -159,6 +182,14 @@ declare function usePatchesSync(): UsePatchesSyncReturn;
  * Type for document ID - can be static string or accessor function.
  */
 type MaybeAccessor<T> = T | Accessor<T>;
+/**
+ * Props for the Provider component returned by createPatchesDoc.
+ */
+interface PatchesDocProviderProps {
+    docId: MaybeAccessor<string>;
+    autoClose?: boolean | 'untrack';
+    children: any;
+}
 /**
  * Creates a named document context that can be provided to child components.
  *
@@ -199,36 +230,10 @@ type MaybeAccessor<T> = T | Accessor<T>;
  *
  * @param name - Unique identifier for this document context (e.g., 'whiteboard', 'user')
  * @returns Object with Provider component and useDoc hook
- *
- * @example
- * ```tsx
- * // Create the context
- * const { Provider: WhiteboardProvider, useDoc: useWhiteboard } =
- *   createPatchesDoc<WhiteboardDoc>('whiteboard');
- *
- * // Use in parent
- * <WhiteboardProvider docId="whiteboard-123">
- *   <Canvas />
- * </WhiteboardProvider>
- *
- * // Use in child
- * function Canvas() {
- *   const { data, change } = useWhiteboard();
- *   return <div>{data()?.title}</div>;
- * }
- * ```
  */
-/**
- * Props for the Provider component returned by createPatchesDoc.
- */
-interface PatchesDocProviderProps {
-    docId: MaybeAccessor<string>;
-    autoClose?: boolean;
-    children: any;
-}
 declare function createPatchesDoc<T extends object>(name: string): {
     Provider: (props: PatchesDocProviderProps) => any;
     useDoc: () => UsePatchesDocReturn<T>;
 };
 
-export { type MaybeAccessor, type PatchesDocProviderProps, type UsePatchesDocOptions, type UsePatchesDocReturn, type UsePatchesSyncReturn, createPatchesDoc, usePatchesDoc, usePatchesSync };
+export { type MaybeAccessor, type PatchesDocProviderProps, type UsePatchesDocLazyOptions, type UsePatchesDocLazyReturn, type UsePatchesDocOptions, type UsePatchesDocReturn, type UsePatchesSyncReturn, createPatchesDoc, usePatchesDoc, usePatchesSync };

package/dist/solid/primitives.js

@@ -7,11 +7,19 @@ import {
   createEffect,
   onCleanup
 } from "solid-js";
+import { JSONPatch } from "../json-patch/JSONPatch.js";
 import { usePatchesContext } from "./context.js";
 import { getDocManager } from "./doc-manager.js";
-function usePatchesDoc(docId, options = {}) {
+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";
   const [doc, setDoc] = createSignal(void 0);
   const [data, setData] = createSignal(void 0);
   const [loading, setLoading] = createSignal(true);
@@ -52,7 +60,7 @@ function usePatchesDoc(docId, options = {}) {
     });
     onCleanup(() => {
       const id = docIdAccessor();
-      manager.closeDoc(patches, id);
+      manager.closeDoc(patches, id, shouldUntrack);
     });
   } else {
     createEffect(() => {
@@ -87,6 +95,104 @@ function usePatchesDoc(docId, options = {}) {
     doc
   };
 }
+function _usePatchesDocLazy(options) {
+  const { patches } = usePatchesContext();
+  const { idProp } = options;
+  let currentDoc = null;
+  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);
+  }
+  async function load(docPath) {
+    if (path()) {
+      const prevPath = path();
+      teardown();
+      await patches.closeDoc(prevPath);
+    }
+    setPath(docPath);
+    try {
+      const patchesDoc = await patches.openDoc(docPath);
+      setupDoc(patchesDoc);
+    } catch (err) {
+      setError(err);
+      setLoading(false);
+    }
+  }
+  async function close() {
+    if (path()) {
+      const prevPath = path();
+      teardown();
+      setPath(null);
+      await patches.closeDoc(prevPath);
+    }
+  }
+  async function create(docPath, initialState) {
+    const newDoc = await patches.openDoc(docPath);
+    newDoc.change((patch, root) => {
+      if (initialState instanceof JSONPatch) {
+        patch.ops = initialState.ops;
+      } else {
+        const state = { ...initialState };
+        if (idProp) delete state[idProp];
+        patch.replace(root, state);
+      }
+    });
+    await patches.closeDoc(docPath);
+  }
+  function change(mutator) {
+    currentDoc?.change(mutator);
+  }
+  return {
+    data,
+    loading,
+    error,
+    rev,
+    hasPending,
+    change,
+    doc,
+    path,
+    load,
+    close,
+    create
+  };
+}
 function usePatchesSync() {
   const { sync } = usePatchesContext();
   if (!sync) {
@@ -118,6 +224,7 @@ function createPatchesDoc(name) {
     const { patches } = usePatchesContext();
     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);
@@ -158,13 +265,13 @@ function createPatchesDoc(name) {
       createEffect((prevId) => {
         const currentId = docIdAccessor();
         if (prevId && prevId !== currentId) {
-          manager.closeDoc(patches, prevId);
+          manager.closeDoc(patches, prevId, shouldUntrack);
         }
         return currentId;
       });
       onCleanup(() => {
         const id = docIdAccessor();
-        manager.closeDoc(patches, id);
+        manager.closeDoc(patches, id, shouldUntrack);
       });
     } else {
       createEffect((prevId) => {

package/dist/solid/utils.d.ts

@@ -0,0 +1 @@
+export { areSetsEqual, fillPath } from '../shared/utils.js';

package/dist/solid/utils.js

@@ -0,0 +1,6 @@
+import "../chunk-IZ2YBCUP.js";
+import { fillPath, areSetsEqual } from "../shared/utils.js";
+export {
+  areSetsEqual,
+  fillPath
+};

package/dist/vue/composables.d.ts

@@ -1,27 +1,38 @@
 import { ShallowRef, Ref, MaybeRef } from 'vue';
 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 '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 
 /**
- * Options for usePatchesDoc composable.
+ * Options for usePatchesDoc composable (eager mode with docId).
  */
 interface UsePatchesDocOptions {
     /**
-     * Whether to automatically open/close the document based on component lifecycle.
+     * Controls document lifecycle management on component unmount.
      *
-     * - `false` (default): Assumes doc is already open. Throws if not.
-     * - `true`: Opens doc on mount with ref counting, closes on unmount.
+     * - `false` (default): Explicit mode. Assumes doc is already open. Throws if not.
+     * - `true`: Opens doc on mount with ref counting, closes on unmount (doc stays tracked).
+     * - `'untrack'`: Opens doc on mount, closes AND untracks on unmount (removes from sync).
      *
      * @default false
      */
-    autoClose?: boolean;
+    autoClose?: boolean | 'untrack';
 }
 /**
- * Return type for usePatchesDoc composable.
+ * Options for usePatchesDoc composable (lazy mode without docId).
+ */
+interface UsePatchesDocLazyOptions {
+    /**
+     * 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.
+     */
+    idProp?: string;
+}
+/**
+ * Return type for usePatchesDoc composable (eager mode).
  */
 interface UsePatchesDocReturn<T extends object> {
     /**
@@ -65,50 +76,71 @@ interface UsePatchesDocReturn<T extends object> {
      */
     doc: Ref<PatchesDoc<T> | undefined>;
 }
+/**
+ * Return type for usePatchesDoc composable (lazy mode).
+ * Extends the eager return type with lifecycle management methods.
+ */
+interface UsePatchesDocLazyReturn<T extends object> extends UsePatchesDocReturn<T> {
+    /**
+     * Current document path. `null` when no document is loaded.
+     */
+    path: Ref<string | null>;
+    /**
+     * Open a document by path. Closes any previously loaded document first.
+     *
+     * @param docPath - The document path to open
+     */
+    load: (docPath: string) => Promise<void>;
+    /**
+     * Close the current document, unsubscribe, and reset all state.
+     * Calls `patches.closeDoc()` but does not untrack — tracking is managed separately.
+     */
+    close: () => Promise<void>;
+    /**
+     * Create a new document: open it, set initial state, then close it.
+     * A one-shot operation that doesn't bind the document to this handle.
+     *
+     * @param docPath - The document path to create
+     * @param initialState - Initial state object or JSONPatch to apply
+     */
+    create: (docPath: string, initialState: T | JSONPatch) => Promise<void>;
+}
 /**
  * Vue composable for reactive Patches document state.
  *
- * Provides reactive access to a Patches document with automatic lifecycle management.
- *
- * ## Explicit Lifecycle (default)
+ * ## Eager Mode (with docId)
  *
- * By default, assumes the document is already open and just adds Vue reactivity.
- * You control when documents are opened and closed.
+ * Provides reactive access to an already-open Patches document.
  *
  * @example
  * ```typescript
- * // Component.vue
- * const props = defineProps(['docId'])
- * const { patches } = usePatchesContext()
- *
- * // You control lifecycle
- * onMounted(() => patches.openDoc(props.docId))
- * onBeforeUnmount(() => patches.closeDoc(props.docId))
+ * // Explicit lifecycle — you control open/close
+ * const { data, loading, change } = usePatchesDoc('doc-123')
  *
- * // Just adds reactivity
- * const { data, loading, change } = usePatchesDoc(props.docId)
+ * // Auto lifecycle — opens on mount, closes on unmount
+ * const { data, loading, change } = usePatchesDoc('doc-123', { autoClose: true })
  * ```
  *
- * ## Auto Lifecycle
+ * ## Lazy Mode (without docId)
  *
- * With `autoClose: true`, the composable manages the document lifecycle with
- * reference counting. Safe to use in multiple components with the same docId.
+ * Returns a deferred handle with `load()`, `close()`, and `create()` methods.
+ * Ideal for Pinia stores where the document path isn't known at creation time.
+ * Does NOT use `onBeforeUnmount` — caller manages lifecycle.
  *
  * @example
  * ```typescript
- * // Opens on mount, closes on unmount (ref-counted)
- * const { data, loading, change } = usePatchesDoc('doc-123', {
- *   autoClose: true
- * })
- * ```
+ * // In a Pinia store
+ * const { data, load, close, change, create } = usePatchesDoc<Project>()
  *
- * @param docId - Document ID to open
- * @param options - Configuration options
- * @returns Reactive document state and utilities
- * @throws Error if Patches context not provided
- * @throws Error if doc not open in explicit mode
+ * // Later, when the user navigates:
+ * await load('projects/abc/content')
+ *
+ * // When leaving:
+ * await close()
+ * ```
  */
 declare function usePatchesDoc<T extends object>(docId: string, options?: UsePatchesDocOptions): UsePatchesDocReturn<T>;
+declare function usePatchesDoc<T extends object>(options?: UsePatchesDocLazyOptions): UsePatchesDocLazyReturn<T>;
 /**
  * Return type for usePatchesSync composable.
  */
@@ -203,4 +235,4 @@ declare function providePatchesDoc<T extends object>(name: string, docId: MaybeR
  */
 declare function useCurrentDoc<T extends object>(name: string): UsePatchesDocReturn<T>;
 
-export { type UsePatchesDocOptions, type UsePatchesDocReturn, type UsePatchesSyncReturn, providePatchesDoc, useCurrentDoc, usePatchesDoc, usePatchesSync };
+export { type UsePatchesDocLazyOptions, type UsePatchesDocLazyReturn, type UsePatchesDocOptions, type UsePatchesDocReturn, type UsePatchesSyncReturn, providePatchesDoc, useCurrentDoc, usePatchesDoc, usePatchesSync };

package/dist/vue/composables.js

@@ -8,11 +8,19 @@ import {
   provide,
   inject
 } from "vue";
+import { JSONPatch } from "../json-patch/JSONPatch.js";
 import { usePatchesContext } from "./provider.js";
 import { getDocManager } from "./doc-manager.js";
-function usePatchesDoc(docId, options = {}) {
+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";
   const doc = ref(void 0);
   const data = shallowRef(void 0);
   const loading = ref(true);
@@ -45,7 +53,7 @@ function usePatchesDoc(docId, options = {}) {
     });
     onBeforeUnmount(() => {
       unsubscribers.forEach((unsub) => unsub());
-      manager.closeDoc(patches, docId);
+      manager.closeDoc(patches, docId, shouldUntrack);
     });
   } else {
     const patchesDoc = patches.getOpenDoc(docId);
@@ -77,6 +85,104 @@ function usePatchesDoc(docId, options = {}) {
     doc
   };
 }
+function _usePatchesDocLazy(options) {
+  const { patches } = usePatchesContext();
+  const { idProp } = options;
+  let currentDoc = null;
+  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;
+  }
+  async function load(docPath) {
+    if (path.value) {
+      const prevPath = path.value;
+      teardown();
+      await patches.closeDoc(prevPath);
+    }
+    path.value = docPath;
+    try {
+      const patchesDoc = await patches.openDoc(docPath);
+      setupDoc(patchesDoc);
+    } catch (err) {
+      error.value = err;
+      loading.value = false;
+    }
+  }
+  async function close() {
+    if (path.value) {
+      const prevPath = path.value;
+      teardown();
+      path.value = null;
+      await patches.closeDoc(prevPath);
+    }
+  }
+  async function create(docPath, initialState) {
+    const newDoc = await patches.openDoc(docPath);
+    newDoc.change((patch, root) => {
+      if (initialState instanceof JSONPatch) {
+        patch.ops = initialState.ops;
+      } else {
+        const state = { ...initialState };
+        if (idProp) delete state[idProp];
+        patch.replace(root, state);
+      }
+    });
+    await patches.closeDoc(docPath);
+  }
+  function change(mutator) {
+    currentDoc?.change(mutator);
+  }
+  return {
+    data,
+    loading,
+    error,
+    rev,
+    hasPending,
+    change,
+    doc,
+    path,
+    load,
+    close,
+    create
+  };
+}
 function usePatchesSync() {
   const { sync } = usePatchesContext();
   if (!sync) {
@@ -105,6 +211,7 @@ function createDocInjectionKey(name) {
 function providePatchesDoc(name, docId, options = {}) {
   const { patches } = usePatchesContext();
   const { autoClose = false } = options;
+  const shouldUntrack = autoClose === "untrack";
   const manager = getDocManager(patches);
   const doc = ref(void 0);
   const data = shallowRef(void 0);
@@ -181,7 +288,7 @@ function providePatchesDoc(name, docId, options = {}) {
       unsubscribers.forEach((unsub) => unsub());
       unsubscribers.length = 0;
       if (autoClose) {
-        await manager.closeDoc(patches, oldDocId);
+        await manager.closeDoc(patches, oldDocId, shouldUntrack);
       } else {
         manager.decrementRefCount(oldDocId);
       }
@@ -191,7 +298,7 @@ function providePatchesDoc(name, docId, options = {}) {
   onBeforeUnmount(async () => {
     unsubscribers.forEach((unsub) => unsub());
     if (autoClose) {
-      await manager.closeDoc(patches, currentDocId.value);
+      await manager.closeDoc(patches, currentDocId.value, shouldUntrack);
     } else {
       manager.decrementRefCount(currentDocId.value);
     }