@dabble/patches 0.7.9 → 0.7.11

package/dist/{BaseDoc-_Rsau70J.d.ts → BaseDoc-BfVJNeCi.d.ts}

@@ -1,6 +1,6 @@
 import { Signal, Unsubscriber } from './event-signal.js';
 import { JSONPatchOp } from './json-patch/types.js';
-import { Change, PatchesSnapshot, SyncingState, ChangeMutator } from './types.js';
+import { Change, PatchesSnapshot, SyncedDoc, DocSyncStatus, ChangeMutator } from './types.js';
 
 /**
  * OT (Operational Transformation) document implementation.
@@ -96,9 +96,9 @@ interface PatchesDocOptions {
  * This interface is implemented by both OTDoc (Operational Transformation)
  * and LWWDoc (Last-Write-Wins) implementations via BaseDoc.
  *
- * Internal methods (updateSyncing, applyChanges, import) are on BaseDoc, not this interface.
+ * Internal methods (updateSyncStatus, applyChanges, import) are on BaseDoc, not this interface.
  */
-interface PatchesDoc<T extends object = object> {
+interface PatchesDoc<T extends object = object> extends SyncedDoc {
     /** The unique identifier for this document. */
     readonly id: string;
     /** Current local state (committed + pending merged). */
@@ -107,8 +107,12 @@ interface PatchesDoc<T extends object = object> {
     readonly committedRev: number;
     /** Are there local changes that haven't been committed yet? */
     readonly hasPending: boolean;
-    /** Are we currently syncing this document? */
-    readonly syncing: SyncingState;
+    /** Current sync status of this document. */
+    readonly syncStatus: DocSyncStatus;
+    /** Error from the last failed sync attempt, if any. */
+    readonly syncError: Error | null;
+    /** Whether the document has completed its initial load. Sticky: once true, never reverts to false. */
+    readonly isLoaded: boolean;
     /**
      * Subscribe to be notified when the user makes local changes.
      * Emits the JSON Patch ops captured from the change() call.
@@ -117,8 +121,8 @@ interface PatchesDoc<T extends object = object> {
     readonly onChange: Signal<(ops: JSONPatchOp[]) => void>;
     /** Subscribe to be notified whenever state changes from any source. */
     readonly onUpdate: Signal<(newState: T) => void>;
-    /** Subscribe to be notified when syncing state changes. */
-    readonly onSyncing: Signal<(newSyncing: SyncingState) => void>;
+    /** Subscribe to be notified when sync status changes. */
+    readonly onSyncStatus: Signal<(newStatus: DocSyncStatus) => void>;
     /** Subscribe to be notified whenever the state changes (calls immediately with current state). */
     subscribe(onUpdate: (newValue: T) => void): Unsubscriber;
     /**
@@ -137,13 +141,15 @@ interface PatchesDoc<T extends object = object> {
  * apply locally. The algorithm handles packaging ops, persisting them, and updating
  * the doc's state via `applyChanges()`.
  *
- * Internal methods (updateSyncing, applyChanges, import) are on this class but not
+ * Internal methods (updateSyncStatus, applyChanges, import) are on this class but not
  * on the PatchesDoc interface, as they're only used by Algorithm and PatchesSync.
  */
 declare abstract class BaseDoc<T extends object = object> implements PatchesDoc<T> {
     protected _id: string;
     protected _state: T;
-    protected _syncing: SyncingState;
+    protected _syncStatus: DocSyncStatus;
+    protected _syncError: Error | null;
+    protected _isLoaded: boolean;
     /**
      * Subscribe to be notified when the user makes local changes.
      * Emits the JSON Patch ops captured from the change() call.
@@ -152,8 +158,8 @@ declare abstract class BaseDoc<T extends object = object> implements PatchesDoc<
     readonly onChange: Signal<(ops: JSONPatchOp[]) => void>;
     /** Subscribe to be notified whenever state changes from any source. */
     readonly onUpdate: Signal<(newState: T) => void>;
-    /** Subscribe to be notified when syncing state changes. */
-    readonly onSyncing: Signal<(newSyncing: SyncingState) => void>;
+    /** Subscribe to be notified when sync status changes. */
+    readonly onSyncStatus: Signal<(newStatus: DocSyncStatus) => void>;
     /**
      * Creates an instance of BaseDoc.
      * @param id The unique identifier for this document.
@@ -164,8 +170,12 @@ declare abstract class BaseDoc<T extends object = object> implements PatchesDoc<
     get id(): string;
     /** Current local state (committed + pending merged). */
     get state(): T;
-    /** Are we currently syncing this document? */
-    get syncing(): SyncingState;
+    /** Current sync status of this document. */
+    get syncStatus(): DocSyncStatus;
+    /** Error from the last failed sync attempt, if any. */
+    get syncError(): Error | null;
+    /** Whether the document has completed its initial load. Sticky: once true, never reverts to false. */
+    get isLoaded(): boolean;
     /** Last committed revision number from the server. */
     abstract get committedRev(): number;
     /** Are there local changes that haven't been committed yet? */
@@ -179,11 +189,14 @@ declare abstract class BaseDoc<T extends object = object> implements PatchesDoc<
      */
     change(mutator: ChangeMutator<T>): void;
     /**
-     * Updates the syncing state of the document.
+     * Updates the sync status of the document.
      * Called by PatchesSync - not part of the app-facing PatchesDoc interface.
-     * @param newSyncing The new syncing state.
+     * @param status The new sync status.
+     * @param error Optional error when status is 'error'.
      */
-    updateSyncing(newSyncing: SyncingState): void;
+    updateSyncStatus(status: DocSyncStatus, error?: Error): void;
+    /** Latches _isLoaded to true when the doc has data or sync has resolved. */
+    protected _checkLoaded(): void;
     /**
      * Applies changes to the document state.
      * Called by Algorithm for local changes and broadcasts - not part of PatchesDoc interface.

package/dist/client/BaseDoc.d.ts

@@ -1,6 +1,6 @@
 import '../event-signal.js';
 import '../json-patch/types.js';
 import '../types.js';
-export { B as BaseDoc } from '../BaseDoc-_Rsau70J.js';
+export { B as BaseDoc } from '../BaseDoc-BfVJNeCi.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/BaseDoc.js

@@ -1,10 +1,13 @@
 import "../chunk-IZ2YBCUP.js";
 import { signal } from "../event-signal.js";
 import { createJSONPatch } from "../json-patch/createJSONPatch.js";
+import { isDocLoaded } from "../shared/utils.js";
 class BaseDoc {
   _id;
   _state;
-  _syncing = null;
+  _syncStatus = "unsynced";
+  _syncError = null;
+  _isLoaded = false;
   /**
    * Subscribe to be notified when the user makes local changes.
    * Emits the JSON Patch ops captured from the change() call.
@@ -13,8 +16,8 @@ class BaseDoc {
   onChange = signal();
   /** Subscribe to be notified whenever state changes from any source. */
   onUpdate = signal();
-  /** Subscribe to be notified when syncing state changes. */
-  onSyncing = signal();
+  /** Subscribe to be notified when sync status changes. */
+  onSyncStatus = signal();
   /**
    * Creates an instance of BaseDoc.
    * @param id The unique identifier for this document.
@@ -32,9 +35,17 @@ class BaseDoc {
   get state() {
     return this._state;
   }
-  /** Are we currently syncing this document? */
-  get syncing() {
-    return this._syncing;
+  /** Current sync status of this document. */
+  get syncStatus() {
+    return this._syncStatus;
+  }
+  /** Error from the last failed sync attempt, if any. */
+  get syncError() {
+    return this._syncError;
+  }
+  /** Whether the document has completed its initial load. Sticky: once true, never reverts to false. */
+  get isLoaded() {
+    return this._isLoaded;
   }
   /** Subscribe to be notified whenever the state changes (calls immediately with current state). */
   subscribe(onUpdate) {
@@ -56,13 +67,22 @@ class BaseDoc {
   }
   // --- Internal methods (not on PatchesDoc interface) ---
   /**
-   * Updates the syncing state of the document.
+   * Updates the sync status of the document.
    * Called by PatchesSync - not part of the app-facing PatchesDoc interface.
-   * @param newSyncing The new syncing state.
+   * @param status The new sync status.
+   * @param error Optional error when status is 'error'.
    */
-  updateSyncing(newSyncing) {
-    this._syncing = newSyncing;
-    this.onSyncing.emit(newSyncing);
+  updateSyncStatus(status, error) {
+    this._syncStatus = status;
+    this._syncError = status === "error" ? error ?? null : null;
+    this._checkLoaded();
+    this.onSyncStatus.emit(status);
+  }
+  /** Latches _isLoaded to true when the doc has data or sync has resolved. */
+  _checkLoaded() {
+    if (!this._isLoaded && isDocLoaded(this)) {
+      this._isLoaded = true;
+    }
   }
 }
 export {

package/dist/client/ClientAlgorithm.d.ts

@@ -1,6 +1,6 @@
 import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
-import { a as PatchesDoc } from '../BaseDoc-_Rsau70J.js';
+import { a as PatchesDoc } from '../BaseDoc-BfVJNeCi.js';
 import { PatchesStore, TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/LWWAlgorithm.d.ts

@@ -2,7 +2,7 @@ import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
 import { LWWClientStore } from './LWWClientStore.js';
-import { a as PatchesDoc } from '../BaseDoc-_Rsau70J.js';
+import { a as PatchesDoc } from '../BaseDoc-BfVJNeCi.js';
 import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/LWWDoc.d.ts

@@ -1,5 +1,5 @@
 import { PatchesSnapshot, Change } from '../types.js';
-import { B as BaseDoc } from '../BaseDoc-_Rsau70J.js';
+import { B as BaseDoc } from '../BaseDoc-BfVJNeCi.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';

package/dist/client/LWWDoc.js

@@ -21,6 +21,7 @@ class LWWDoc extends BaseDoc {
         }
       }
     }
+    this._checkLoaded();
   }
   /** Last committed revision number from the server. */
   get committedRev() {
@@ -45,6 +46,7 @@ class LWWDoc extends BaseDoc {
         }
       }
     }
+    this._checkLoaded();
     this.onUpdate.emit(this._state);
   }
   /**
@@ -78,6 +80,7 @@ class LWWDoc extends BaseDoc {
     }
     this._committedRev = lastCommittedRev;
     this._hasPending = hasPending ?? hasPendingChanges;
+    this._checkLoaded();
     this.onUpdate.emit(this._state);
   }
 }

package/dist/client/OTAlgorithm.d.ts

@@ -2,7 +2,7 @@ import { JSONPatchOp } from '../json-patch/types.js';
 import { PatchesSnapshot, Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
 import { OTClientStore } from './OTClientStore.js';
-import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-_Rsau70J.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-BfVJNeCi.js';
 import { TrackedDoc } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/OTDoc.d.ts

@@ -1,5 +1,5 @@
 import '../types.js';
-export { O as OTDoc } from '../BaseDoc-_Rsau70J.js';
+export { O as OTDoc } from '../BaseDoc-BfVJNeCi.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';

package/dist/client/OTDoc.js

@@ -23,6 +23,7 @@ class OTDoc extends BaseDoc {
     if (this._pendingChanges.length > 0) {
       this._state = applyChangesToState(this._committedState, this._pendingChanges);
     }
+    this._checkLoaded();
   }
   /** Last committed revision number from the server. */
   get committedRev() {
@@ -48,6 +49,7 @@ class OTDoc extends BaseDoc {
     this._committedRev = snapshot.rev;
     this._pendingChanges = snapshot.changes;
     this._state = createStateFromSnapshot(snapshot);
+    this._checkLoaded();
     this.onUpdate.emit(this._state);
   }
   /**
@@ -79,6 +81,7 @@ class OTDoc extends BaseDoc {
       this._state = applyChangesToState(this._state, changes);
       this._pendingChanges.push(...changes);
     }
+    this._checkLoaded();
     this.onUpdate.emit(this._state);
   }
   /**

package/dist/client/Patches.d.ts

@@ -2,7 +2,7 @@ import { Unsubscriber, Signal } from '../event-signal.js';
 import { JSONPatchOp } from '../json-patch/types.js';
 import { Change } from '../types.js';
 import { ClientAlgorithm } from './ClientAlgorithm.js';
-import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-_Rsau70J.js';
+import { P as PatchesDocOptions, a as PatchesDoc } from '../BaseDoc-BfVJNeCi.js';
 import { AlgorithmName } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/PatchesDoc.d.ts

@@ -1,6 +1,6 @@
 import '../event-signal.js';
 import '../json-patch/types.js';
 import '../types.js';
-export { O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-_Rsau70J.js';
+export { O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-BfVJNeCi.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/factories.d.ts

@@ -1,6 +1,6 @@
 import { AlgorithmName } from './PatchesStore.js';
 import { Patches } from './Patches.js';
-import { P as PatchesDocOptions } from '../BaseDoc-_Rsau70J.js';
+import { P as PatchesDocOptions } from '../BaseDoc-BfVJNeCi.js';
 import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';

package/dist/client/index.d.ts

@@ -1,4 +1,4 @@
-export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-_Rsau70J.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from '../BaseDoc-BfVJNeCi.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './IndexedDBStore.js';
 export { OTIndexedDBStore } from './OTIndexedDBStore.js';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { Delta } from '@dabble/delta';
-export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from './BaseDoc-_Rsau70J.js';
+export { B as BaseDoc, O as OTDoc, a as PatchesDoc, O as PatchesDocClass, P as PatchesDocOptions } from './BaseDoc-BfVJNeCi.js';
 export { IndexedDBFactoryOptions, MultiAlgorithmFactoryOptions, MultiAlgorithmIndexedDBFactoryOptions, PatchesFactoryOptions, createLWWIndexedDBPatches, createLWWPatches, createMultiAlgorithmIndexedDBPatches, createMultiAlgorithmPatches, createOTIndexedDBPatches, createOTPatches } from './client/factories.js';
 export { IDBStoreWrapper, IDBTransactionWrapper, IndexedDBStore } from './client/IndexedDBStore.js';
 export { OTIndexedDBStore } from './client/OTIndexedDBStore.js';
@@ -29,7 +29,7 @@ export { createPathProxy, pathProxy } from './json-patch/pathProxy.js';
 export { transformPatch } from './json-patch/transformPatch.js';
 export { JSONPatch, PathLike, WriteOptions } from './json-patch/JSONPatch.js';
 export { ApplyJSONPatchOptions, JSONPatchOpHandlerMap as JSONPatchCustomTypes, JSONPatchOp } from './json-patch/types.js';
-export { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata } from './types.js';
+export { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocSyncStatus, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncedDoc, VersionMetadata } from './types.js';
 export { add } from './json-patch/ops/add.js';
 export { copy } from './json-patch/ops/copy.js';
 export { increment } from './json-patch/ops/increment.js';

package/dist/net/PatchesSync.d.ts

@@ -1,6 +1,6 @@
 import { Signal } from '../event-signal.js';
 import { ConnectionState } from './protocol/types.js';
-import { SyncingState, Change } from '../types.js';
+import { DocSyncStatus, SyncedDoc, Change } from '../types.js';
 import { JSONRPCClient } from './protocol/JSONRPCClient.js';
 import { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
 import { WebSocketOptions } from './websocket/WebSocketTransport.js';
@@ -13,12 +13,13 @@ import '@dabble/delta';
 import '../json-patch/types.js';
 import './PatchesClient.js';
 import '../utils/deferred.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 
 interface PatchesSyncState {
     online: boolean;
     connected: boolean;
-    syncing: SyncingState;
+    syncStatus: DocSyncStatus;
+    syncError: Error | null;
 }
 interface PatchesSyncOptions {
     subscribeFilter?: (docIds: string[]) => string[];
@@ -50,6 +51,7 @@ declare class PatchesSync {
     /** Maps docId to the algorithm name used for that doc */
     protected docAlgorithms: Map<string, AlgorithmName>;
     protected _state: PatchesSyncState;
+    protected _syncedDocs: Record<string, SyncedDoc>;
     /**
      * Signal emitted when the sync state changes.
      */
@@ -65,6 +67,10 @@ declare class PatchesSync {
      * Provides the pending changes that were discarded so the application can handle them.
      */
     readonly onRemoteDocDeleted: Signal<(docId: string, pendingChanges: Change[]) => void>;
+    /**
+     * Signal emitted when the synced doc map changes.
+     */
+    readonly onSyncedDocsChange: Signal<(synced: Record<string, SyncedDoc>) => void>;
     constructor(patches: Patches, url: string, options?: PatchesSyncOptions | undefined);
     /**
      * Gets the algorithm for a document. Uses the open doc's algorithm if available,
@@ -83,6 +89,11 @@ declare class PatchesSync {
      * Gets the current sync state.
      */
     get state(): PatchesSyncState;
+    /**
+     * Map of all tracked documents and their current sync status.
+     * Updated immutably — new object reference on every change.
+     */
+    get syncedDocs(): Record<string, SyncedDoc>;
     /**
      * Gets the JSON-RPC client for making custom RPC calls.
      * Useful for application-specific methods not part of the Patches protocol.
@@ -142,6 +153,21 @@ declare class PatchesSync {
      * Cleans up local state and notifies the application with any pending changes that were lost.
      */
     protected _handleRemoteDocDeleted(docId: string): Promise<void>;
+    /**
+     * Adds, updates, or removes a synced doc entry immutably and emits onSyncedChange.
+     * - Pass a full SyncedDoc to add a new entry or overwrite an existing one.
+     * - Pass a Partial<SyncedDoc> to merge into an existing entry (no-ops if doc not in map).
+     * - Pass undefined to remove the entry.
+     * No-ops if nothing actually changed.
+     */
+    protected _updateSyncedDoc(docId: string, updates: Partial<SyncedDoc> | undefined, emit?: boolean): void;
+    protected _emitSyncedChange(): void;
+    /**
+     * Resets any docs with status 'syncing' back to a stable state on disconnect.
+     * Uses hasPending to decide: pending docs become 'synced' (they have local data),
+     * docs with no pending and no committed rev become 'unsynced'.
+     */
+    protected _resetSyncingStatuses(): void;
     /**
      * Applies the subscribeFilter option to a list of doc IDs, returning the subset
      * that should be sent to ws.subscribe/unsubscribe. Returns the full list if no filter is set.

package/dist/net/PatchesSync.js

@@ -11,9 +11,17 @@ import { breakChangesIntoBatches } from "../algorithms/ot/shared/changeBatching.
 import { BaseDoc } from "../client/BaseDoc.js";
 import { Patches } from "../client/Patches.js";
 import { signal } from "../event-signal.js";
+import { isDocLoaded } from "../shared/utils.js";
 import { blockable } from "../utils/concurrency.js";
 import { PatchesWebSocket } from "./websocket/PatchesWebSocket.js";
 import { onlineState } from "./websocket/onlineState.js";
+const EMPTY_SYNCED_DOC = {
+  committedRev: 0,
+  hasPending: false,
+  syncStatus: "unsynced",
+  syncError: null,
+  isLoaded: false
+};
 _syncDoc_dec = [blockable], __receiveCommittedChanges_dec = [blockable];
 class PatchesSync {
   constructor(patches, url, options) {
@@ -27,7 +35,8 @@ class PatchesSync {
     __publicField(this, "trackedDocs");
     /** Maps docId to the algorithm name used for that doc */
     __publicField(this, "docAlgorithms", /* @__PURE__ */ new Map());
-    __publicField(this, "_state", { online: false, connected: false, syncing: null });
+    __publicField(this, "_state", { online: false, connected: false, syncStatus: "unsynced", syncError: null });
+    __publicField(this, "_syncedDocs", {});
     /**
      * Signal emitted when the sync state changes.
      */
@@ -41,6 +50,10 @@ class PatchesSync {
      * Provides the pending changes that were discarded so the application can handle them.
      */
     __publicField(this, "onRemoteDocDeleted", signal());
+    /**
+     * Signal emitted when the synced doc map changes.
+     */
+    __publicField(this, "onSyncedDocsChange", signal());
     this.patches = patches;
     this.maxPayloadBytes = options?.maxPayloadBytes;
     this.maxStorageBytes = options?.maxStorageBytes ?? patches.docOptions?.maxStorageBytes;
@@ -93,6 +106,13 @@ class PatchesSync {
   get state() {
     return this._state;
   }
+  /**
+   * Map of all tracked documents and their current sync status.
+   * Updated immutably — new object reference on every change.
+   */
+  get syncedDocs() {
+    return this._syncedDocs;
+  }
   /**
    * Gets the JSON-RPC client for making custom RPC calls.
    * Useful for application-specific methods not part of the Patches protocol.
@@ -106,6 +126,9 @@ class PatchesSync {
    */
   updateState(update) {
     const newState = { ...this._state, ...update };
+    if (newState.syncStatus !== "error" && newState.syncError) {
+      newState.syncError = null;
+    }
     if (!isEqual(this._state, newState)) {
       this._state = newState;
       this.onStateChange.emit(this._state);
@@ -119,8 +142,9 @@ class PatchesSync {
       await this.ws.connect();
     } catch (err) {
       console.error("PatchesSync connection failed:", err);
-      this.updateState({ connected: false, syncing: err instanceof Error ? err : new Error(String(err)) });
-      this.onError.emit(err);
+      const error = err instanceof Error ? err : new Error(String(err));
+      this.updateState({ connected: false, syncStatus: "error", syncError: error });
+      this.onError.emit(error);
       throw err;
     }
   }
@@ -129,14 +153,15 @@ class PatchesSync {
    */
   disconnect() {
     this.ws.disconnect();
-    this.updateState({ connected: false, syncing: null });
+    this.updateState({ connected: false, syncStatus: "unsynced" });
+    this._resetSyncingStatuses();
   }
   /**
    * Syncs all known docs when initially connected.
    */
   async syncAllKnownDocs() {
     if (!this.state.connected) return;
-    this.updateState({ syncing: "updating" });
+    this.updateState({ syncStatus: "syncing" });
     try {
       const allTracked = [];
       for (const algorithm of Object.values(this.patches.algorithms)) {
@@ -153,6 +178,23 @@ class PatchesSync {
       const deletedDocs = allTracked.filter((t) => t.deleted);
       const activeDocIds = activeDocs.map((t) => t.docId);
       this.trackedDocs = new Set(activeDocIds);
+      const syncedEntries = {};
+      for (const doc of activeDocs) {
+        const algorithm = this._getAlgorithm(doc.docId);
+        const pending = await algorithm.getPendingToSend(doc.docId);
+        const entry = {
+          committedRev: doc.committedRev,
+          hasPending: pending != null && pending.length > 0,
+          syncStatus: doc.committedRev === 0 ? "unsynced" : "synced",
+          syncError: null,
+          isLoaded: false
+        };
+        const existing = this._syncedDocs[doc.docId];
+        entry.isLoaded = existing?.isLoaded || isDocLoaded(entry);
+        syncedEntries[doc.docId] = entry;
+      }
+      this._syncedDocs = syncedEntries;
+      this.onSyncedDocsChange.emit(this._syncedDocs);
       if (activeDocIds.length > 0) {
         try {
           const subscribeIds = this._filterSubscribeIds(activeDocIds);
@@ -178,20 +220,22 @@ class PatchesSync {
         }
       });
       await Promise.all([...activeSyncPromises, ...deletePromises]);
-      this.updateState({ syncing: null });
+      this.updateState({ syncStatus: "synced" });
     } catch (error) {
       console.error("Error during global sync:", error);
-      this.updateState({ syncing: error instanceof Error ? error : new Error(String(error)) });
-      this.onError.emit(error);
+      const syncError = error instanceof Error ? error : new Error(String(error));
+      this.updateState({ syncStatus: "error", syncError });
+      this.onError.emit(syncError);
     }
   }
   async syncDoc(docId) {
     if (!this.state.connected) return;
+    this._updateSyncedDoc(docId, { syncStatus: "syncing" });
     const doc = this.patches.getOpenDoc(docId);
     const algorithm = this._getAlgorithm(docId);
     const baseDoc = doc;
     if (baseDoc) {
-      baseDoc.updateSyncing("updating");
+      baseDoc.updateSyncStatus("syncing");
     }
     try {
       const pending = await algorithm.getPendingToSend(docId);
@@ -207,23 +251,27 @@ class PatchesSync {
         } else {
           const snapshot = await this.ws.getDoc(docId);
           await algorithm.store.saveDoc(docId, snapshot);
+          this._updateSyncedDoc(docId, { committedRev: snapshot.rev });
           if (baseDoc) {
             baseDoc.import({ ...snapshot, changes: [] });
           }
         }
       }
+      this._updateSyncedDoc(docId, { syncStatus: "synced" });
       if (baseDoc) {
-        baseDoc.updateSyncing(null);
+        baseDoc.updateSyncStatus("synced");
       }
     } catch (err) {
       if (this._isDocDeletedError(err)) {
         await this._handleRemoteDocDeleted(docId);
         return;
       }
+      const syncError = err instanceof Error ? err : new Error(String(err));
+      this._updateSyncedDoc(docId, { syncStatus: "error", syncError });
       console.error(`Error syncing doc ${docId}:`, err);
-      this.onError.emit(err, { docId });
+      this.onError.emit(syncError, { docId });
       if (baseDoc) {
-        baseDoc.updateSyncing(err instanceof Error ? err : new Error(String(err)));
+        baseDoc.updateSyncStatus("error", syncError);
       }
     }
   }
@@ -261,13 +309,17 @@ class PatchesSync {
         await algorithm.confirmSent(docId, batch);
         pending = await algorithm.getPendingToSend(docId) ?? [];
       }
+      const stillHasPending = pending != null && pending.length > 0;
+      this._updateSyncedDoc(docId, { hasPending: stillHasPending, syncStatus: "synced" });
     } catch (err) {
       if (this._isDocDeletedError(err)) {
         await this._handleRemoteDocDeleted(docId);
         return;
       }
+      const flushError = err instanceof Error ? err : new Error(String(err));
+      this._updateSyncedDoc(docId, { syncStatus: "error", syncError: flushError });
       console.error(`Flush failed for doc ${docId}:`, err);
-      this.onError.emit(err, { docId });
+      this.onError.emit(flushError, { docId });
       throw err;
     }
   }
@@ -286,6 +338,10 @@ class PatchesSync {
     const doc = this.patches.getOpenDoc(docId);
     const algorithm = this._getAlgorithm(docId);
     await algorithm.applyServerChanges(docId, serverChanges, doc);
+    if (serverChanges.length > 0) {
+      const lastRev = serverChanges[serverChanges.length - 1].rev;
+      this._updateSyncedDoc(docId, { committedRev: lastRev });
+    }
   }
   /**
    * Initiates the deletion process for a document both locally and on the server.
@@ -309,10 +365,12 @@ class PatchesSync {
   _handleConnectionChange(connectionState) {
     const isConnected = connectionState === "connected";
     const isConnecting = connectionState === "connecting";
-    const newSyncingState = isConnected ? this._state.syncing : isConnecting ? this._state.syncing : null;
-    this.updateState({ connected: isConnected, syncing: newSyncingState });
+    const newSyncStatus = isConnected ? this._state.syncStatus : isConnecting ? this._state.syncStatus : "unsynced";
+    this.updateState({ connected: isConnected, syncStatus: newSyncStatus });
     if (isConnected) {
       void this.syncAllKnownDocs();
+    } else if (!isConnecting) {
+      this._resetSyncingStatuses();
     }
   }
   async _handleDocsTracked(docIds) {
@@ -331,6 +389,21 @@ class PatchesSync {
         }
       }
     }
+    for (const docId of newIds) {
+      const algorithm = this._getAlgorithm(docId);
+      const committedRev = await algorithm.getCommittedRev(docId);
+      const pending = await algorithm.getPendingToSend(docId);
+      this._updateSyncedDoc(
+        docId,
+        {
+          committedRev,
+          hasPending: pending != null && pending.length > 0,
+          syncStatus: committedRev === 0 ? "unsynced" : "synced"
+        },
+        false
+      );
+    }
+    this._emitSyncedChange();
     if (this.state.connected) {
       try {
         const subscribeIds = this._filterSubscribeIds(newIds).filter((id) => !alreadySubscribed.has(id));
@@ -349,6 +422,8 @@ class PatchesSync {
     if (!existingIds.length) return;
     const subscribedBefore = this._getActiveSubscriptions();
     existingIds.forEach((id) => this.trackedDocs.delete(id));
+    existingIds.forEach((id) => this._updateSyncedDoc(id, void 0, false));
+    this._emitSyncedChange();
     const subscribedAfter = this._getActiveSubscriptions();
     const unsubscribeIds = [...subscribedBefore].filter((id) => !subscribedAfter.has(id));
     if (this.state.connected && unsubscribeIds.length) {
@@ -360,8 +435,10 @@ class PatchesSync {
     }
   }
   async _handleDocChange(docId) {
-    if (!this.state.connected) return;
     if (!this.trackedDocs.has(docId)) return;
+    this._updateSyncedDoc(docId, { hasPending: true }, !this.state.connected);
+    if (!this.state.connected) return;
+    this._updateSyncedDoc(docId, { syncStatus: "syncing" });
     await this.flushDoc(docId);
   }
   /**
@@ -376,9 +453,54 @@ class PatchesSync {
       await this.patches.closeDoc(docId);
     }
     this.trackedDocs.delete(docId);
+    this._updateSyncedDoc(docId, void 0);
     await algorithm.confirmDeleteDoc(docId);
     await this.onRemoteDocDeleted.emit(docId, pendingChanges);
   }
+  /**
+   * Adds, updates, or removes a synced doc entry immutably and emits onSyncedChange.
+   * - Pass a full SyncedDoc to add a new entry or overwrite an existing one.
+   * - Pass a Partial<SyncedDoc> to merge into an existing entry (no-ops if doc not in map).
+   * - Pass undefined to remove the entry.
+   * No-ops if nothing actually changed.
+   */
+  _updateSyncedDoc(docId, updates, emit = true) {
+    if (updates === void 0) {
+      if (!(docId in this._syncedDocs)) return;
+      this._syncedDocs = { ...this._syncedDocs };
+      delete this._syncedDocs[docId];
+    } else {
+      const updated = { ...EMPTY_SYNCED_DOC, ...this._syncedDocs[docId], ...updates };
+      if (updated.syncStatus !== "error" && updated.syncError) {
+        updated.syncError = null;
+      }
+      if (!updated.isLoaded) {
+        updated.isLoaded = isDocLoaded(updated);
+      }
+      if (isEqual(this._syncedDocs[docId], updated)) return;
+      this._syncedDocs = { ...this._syncedDocs, [docId]: updated };
+    }
+    if (emit) this._emitSyncedChange();
+  }
+  _emitSyncedChange() {
+    this.onSyncedDocsChange.emit(this._syncedDocs);
+  }
+  /**
+   * Resets any docs with status 'syncing' back to a stable state on disconnect.
+   * Uses hasPending to decide: pending docs become 'synced' (they have local data),
+   * docs with no pending and no committed rev become 'unsynced'.
+   */
+  _resetSyncingStatuses() {
+    let changed = false;
+    for (const [docId, doc] of Object.entries(this._syncedDocs)) {
+      if (doc.syncStatus === "syncing") {
+        const newStatus = doc.committedRev === 0 && !doc.hasPending ? "unsynced" : "synced";
+        this._updateSyncedDoc(docId, { syncStatus: newStatus }, false);
+        changed = true;
+      }
+    }
+    if (changed) this._emitSyncedChange();
+  }
   /**
    * Applies the subscribeFilter option to a list of doc IDs, returning the subset
    * that should be sent to ws.subscribe/unsubscribe. Returns the full list if no filter is set.

package/dist/net/index.d.ts

@@ -17,7 +17,7 @@ import '../event-signal.js';
 import '../algorithms/ot/shared/changeBatching.js';
 import '../client/ClientAlgorithm.js';
 import '../json-patch/types.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';
 import '../client/Patches.js';
 import '../server/types.js';

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

@@ -1,5 +1,5 @@
 import { Patches, OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-_Rsau70J.js';
+import { a as PatchesDoc } from '../BaseDoc-BfVJNeCi.js';
 import '../event-signal.js';
 import '../json-patch/types.js';
 import '../types.js';

package/dist/shared/utils.d.ts

@@ -1,3 +1,13 @@
+import { SyncedDoc } from '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';
+
+/**
+ * Returns true if a document has completed its initial load — i.e., it has data
+ * to display (server data, cached data, or local changes) or sync has resolved.
+ */
+declare function isDocLoaded(doc: Pick<SyncedDoc, 'committedRev' | 'hasPending' | 'syncStatus'>): boolean;
 /**
  * Resolves a path template by replacing `:param` placeholders with values.
  *
@@ -19,4 +29,4 @@ declare function fillPath(template: string, params: Record<string, string>): str
  */
 declare function areSetsEqual(a: Set<string>, b: Set<string>): boolean;
 
-export { areSetsEqual, fillPath };
+export { areSetsEqual, fillPath, isDocLoaded };

package/dist/shared/utils.js

@@ -1,4 +1,7 @@
 import "../chunk-IZ2YBCUP.js";
+function isDocLoaded(doc) {
+  return doc.committedRev > 0 || doc.hasPending || doc.syncStatus === "synced" || doc.syncStatus === "error";
+}
 function fillPath(template, params) {
   return template.replace(/:(\w+)/g, (match, name) => {
     const value = params[name];
@@ -18,5 +21,6 @@ function areSetsEqual(a, b) {
 }
 export {
   areSetsEqual,
-  fillPath
+  fillPath,
+  isDocLoaded
 };

package/dist/solid/context.d.ts

@@ -7,7 +7,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';

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

@@ -6,5 +6,5 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';

package/dist/solid/index.d.ts

@@ -11,7 +11,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../net/protocol/types.js';

package/dist/solid/primitives.d.ts

@@ -1,6 +1,6 @@
 import { Accessor } from 'solid-js';
 import { OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-_Rsau70J.js';
+import { a as PatchesDoc } from '../BaseDoc-BfVJNeCi.js';
 import { JSONPatch } from '../json-patch/JSONPatch.js';
 import { ChangeMutator } from '../types.js';
 import '../event-signal.js';

package/dist/solid/primitives.js

@@ -11,7 +11,7 @@ import { JSONPatch } from "../json-patch/JSONPatch.js";
 import { usePatchesContext } from "./context.js";
 import { getDocManager } from "./doc-manager.js";
 function createDocReactiveState(options) {
-  const { initialLoading = true, transformState, changeBehavior } = options;
+  const { initialLoading = true, hasSyncContext = false, transformState, changeBehavior } = options;
   const [doc, setDoc] = createSignal(void 0);
   const [data, setData] = createSignal(void 0);
   const [loading, setLoading] = createSignal(initialLoading);
@@ -20,6 +20,19 @@ function createDocReactiveState(options) {
   const [hasPending, setHasPending] = createSignal(false);
   function setupDoc(patchesDoc) {
     setDoc(patchesDoc);
+    let loaded = false;
+    function updateLoading() {
+      if (loaded) return;
+      if (patchesDoc.isLoaded) {
+        loaded = true;
+        setLoading(false);
+      } else if (patchesDoc.syncStatus === "syncing") {
+        setLoading(true);
+      } else if (!hasSyncContext) {
+        loaded = true;
+        setLoading(false);
+      }
+    }
     const unsubState = patchesDoc.subscribe((state) => {
       if (transformState && state) {
         state = transformState(state, patchesDoc);
@@ -27,12 +40,12 @@ function createDocReactiveState(options) {
       setData(() => state);
       setRev(patchesDoc.committedRev);
       setHasPending(patchesDoc.hasPending);
+      updateLoading();
     });
-    const unsubSync = patchesDoc.onSyncing((syncState) => {
-      setLoading(syncState === "initial" || syncState === "updating");
-      setError(syncState instanceof Error ? syncState : null);
+    const unsubSync = patchesDoc.onSyncStatus((status) => {
+      updateLoading();
+      setError(status === "error" ? patchesDoc.syncError : null);
     });
-    setLoading(patchesDoc.syncing !== null);
     return () => {
       unsubState();
       unsubSync();
@@ -92,12 +105,16 @@ function usePatchesDoc(docIdOrOptions, options) {
   return _usePatchesDocLazy(docIdOrOptions ?? {});
 }
 function _usePatchesDocEager(docId, options) {
-  const { patches } = usePatchesContext();
+  const { patches, sync } = 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 { setupDoc, setError, setLoading, baseReturn } = createDocReactiveState({
+    initialLoading: !!autoClose,
+    hasSyncContext: !!sync,
+    changeBehavior: "throw"
+  });
   const docIdAccessor = toAccessor(docId);
   if (autoClose) {
     const [docResource] = createResource(docIdAccessor, async (id) => {
@@ -139,10 +156,11 @@ function _usePatchesDocEager(docId, options) {
   return baseReturn;
 }
 function _usePatchesDocLazy(options) {
-  const { patches } = usePatchesContext();
+  const { patches, sync } = usePatchesContext();
   const { idProp } = options;
   const { setupDoc, resetSignals, setError, setLoading, baseReturn } = createDocReactiveState({
     initialLoading: false,
+    hasSyncContext: !!sync,
     changeBehavior: "noop",
     transformState: idProp ? (state, patchesDoc) => ({ ...state, [idProp]: patchesDoc.id }) : void 0
   });
@@ -160,6 +178,7 @@ function _usePatchesDocLazy(options) {
       await patches.closeDoc(prevPath);
     }
     setPath(docPath);
+    setLoading(true);
     try {
       const patchesDoc = await patches.openDoc(docPath, options2);
       unsubscribe = setupDoc(patchesDoc);
@@ -197,11 +216,11 @@ function usePatchesSync() {
     throw new Error("PatchesSync not found in context. Did you forget to pass sync to PatchesProvider?");
   }
   const [connected, setConnected] = createSignal(sync.state.connected);
-  const [syncing, setSyncing] = createSignal(sync.state.syncing === "updating");
+  const [syncing, setSyncing] = createSignal(sync.state.syncStatus === "syncing");
   const [online, setOnline] = createSignal(sync.state.online);
   const unsubscribe = sync.onStateChange((state) => {
     setConnected(state.connected);
-    setSyncing(state.syncing === "updating");
+    setSyncing(state.syncStatus === "syncing");
     setOnline(state.online);
   });
   onCleanup(() => {
@@ -219,12 +238,16 @@ function toAccessor(value) {
 function createPatchesDoc(name) {
   const Context = createContext();
   function Provider(props) {
-    const { patches } = usePatchesContext();
+    const { patches, sync } = usePatchesContext();
     const manager = getDocManager(patches);
     const autoClose = props.autoClose ?? false;
     const shouldUntrack = autoClose === "untrack";
     const openDocOpts = { algorithm: props.algorithm, metadata: props.metadata };
-    const { setupDoc, setError, setLoading, baseReturn } = createDocReactiveState({ changeBehavior: "throw" });
+    const { setupDoc, setError, setLoading, baseReturn } = createDocReactiveState({
+      initialLoading: !!autoClose,
+      hasSyncContext: !!sync,
+      changeBehavior: "throw"
+    });
     const docIdAccessor = toAccessor(props.docId);
     if (autoClose) {
       const [docResource] = createResource(docIdAccessor, async (id) => {

package/dist/solid/utils.d.ts

@@ -1 +1,5 @@
 export { areSetsEqual, fillPath } from '../shared/utils.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';

package/dist/types.d.ts

@@ -57,13 +57,30 @@ interface PatchesSnapshot<T = any> extends PatchesState<T> {
     changes: Change[];
 }
 /**
- * Represents the syncing state of a document.
- * @property initial - The document is not syncing.
- * @property updating - The document is syncing.
- * @property null - The document is not syncing.
- * @property Error - The document is syncing with an error.
+ * Sync status for a document, used by both PatchesDoc and PatchesSync's SyncedDoc.
+ * - `'unsynced'` — not yet synced (initial state, or disconnected)
+ * - `'syncing'`  — actively syncing with the server
+ * - `'synced'`   — up to date with the server
+ * - `'error'`    — sync failed (see syncError for details)
  */
-type SyncingState = 'initial' | 'updating' | null | Error;
+type DocSyncStatus = 'unsynced' | 'syncing' | 'synced' | 'error';
+/**
+ * Represents the synced state of a document.
+ * @property committedRev - The last committed revision number from the server.
+ * @property hasPending - Whether there are local changes that haven't been committed yet.
+ * @property syncStatus - The current sync status of the document.
+ * @property syncError - The error from the last failed sync attempt, if any.
+ * @property isLoaded - Whether the document has completed its initial load. Sticky: once true, never reverts to false
+ *   within a sync lifecycle. A document is considered loaded when it has data to display (server data, cached data,
+ *   or local changes) or sync has resolved (successfully or with error).
+ */
+interface SyncedDoc {
+    committedRev: number;
+    hasPending: boolean;
+    syncStatus: DocSyncStatus;
+    syncError: Error | null;
+    isLoaded: boolean;
+}
 /** Status options for a branch */
 type BranchStatus = 'open' | 'closed' | 'merged' | 'archived' | 'abandoned';
 interface Branch {
@@ -220,4 +237,4 @@ type PathProxy<T = any> = IsAny<T> extends true ? DeepPathProxy : {
  */
 type ChangeMutator<T> = (patch: JSONPatch, root: PathProxy<T>) => void;
 
-export type { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncingState, VersionMetadata };
+export type { Branch, BranchStatus, Change, ChangeInput, ChangeMutator, CommitChangesOptions, DeleteDocOptions, DocSyncStatus, DocumentTombstone, EditableBranchMetadata, EditableVersionMetadata, ListChangesOptions, ListVersionsOptions, PatchesSnapshot, PatchesState, PathProxy, SyncedDoc, VersionMetadata };

package/dist/vue/composables.d.ts

@@ -1,6 +1,6 @@
 import { ShallowRef, Ref, MaybeRef } from 'vue';
 import { OpenDocOptions } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-_Rsau70J.js';
+import { a as PatchesDoc } from '../BaseDoc-BfVJNeCi.js';
 import { JSONPatch } from '../json-patch/JSONPatch.js';
 import { ChangeMutator } from '../types.js';
 import '../event-signal.js';

package/dist/vue/composables.js

@@ -12,7 +12,7 @@ import { JSONPatch } from "../json-patch/JSONPatch.js";
 import { usePatchesContext } from "./provider.js";
 import { getDocManager } from "./doc-manager.js";
 function createDocReactiveState(options) {
-  const { initialLoading = true, transformState, changeBehavior } = options;
+  const { initialLoading = true, hasSyncContext = false, transformState, changeBehavior } = options;
   const doc = ref(void 0);
   const data = shallowRef(void 0);
   const loading = ref(initialLoading);
@@ -21,6 +21,19 @@ function createDocReactiveState(options) {
   const hasPending = ref(false);
   function setupDoc(patchesDoc) {
     doc.value = patchesDoc;
+    let loaded = false;
+    function updateLoading() {
+      if (loaded) return;
+      if (patchesDoc.isLoaded) {
+        loaded = true;
+        loading.value = false;
+      } else if (patchesDoc.syncStatus === "syncing") {
+        loading.value = true;
+      } else if (!hasSyncContext) {
+        loaded = true;
+        loading.value = false;
+      }
+    }
     const unsubState = patchesDoc.subscribe((state) => {
       if (transformState && state) {
         state = transformState(state, patchesDoc);
@@ -28,12 +41,12 @@ function createDocReactiveState(options) {
       data.value = state;
       rev.value = patchesDoc.committedRev;
       hasPending.value = patchesDoc.hasPending;
+      updateLoading();
     });
-    const unsubSync = patchesDoc.onSyncing((syncState) => {
-      loading.value = syncState === "initial" || syncState === "updating";
-      error.value = syncState instanceof Error ? syncState : null;
+    const unsubSync = patchesDoc.onSyncStatus((status) => {
+      updateLoading();
+      error.value = status === "error" ? patchesDoc.syncError : null;
     });
-    loading.value = patchesDoc.syncing !== null;
     return () => {
       unsubState();
       unsubSync();
@@ -75,12 +88,16 @@ function usePatchesDoc(docIdOrOptions, options) {
   return _usePatchesDocLazy(docIdOrOptions ?? {});
 }
 function _usePatchesDocEager(docId, options) {
-  const { patches } = usePatchesContext();
+  const { patches, sync } = 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" });
+  const { setupDoc, baseReturn } = createDocReactiveState({
+    initialLoading: !!autoClose,
+    hasSyncContext: !!sync,
+    changeBehavior: "throw"
+  });
   let unsubscribe = null;
   if (autoClose) {
     manager.openDoc(patches, docId, openDocOpts).then((patchesDoc) => {
@@ -110,10 +127,11 @@ function _usePatchesDocEager(docId, options) {
   return baseReturn;
 }
 function _usePatchesDocLazy(options) {
-  const { patches } = usePatchesContext();
+  const { patches, sync } = usePatchesContext();
   const { idProp } = options;
-  const { setupDoc, resetRefs, baseReturn } = createDocReactiveState({
+  const { setupDoc, resetRefs, loading, baseReturn } = createDocReactiveState({
     initialLoading: false,
+    hasSyncContext: !!sync,
     changeBehavior: "noop",
     transformState: idProp ? (state, patchesDoc) => ({ ...state, [idProp]: patchesDoc.id }) : void 0
   });
@@ -131,12 +149,13 @@ function _usePatchesDocLazy(options) {
       await patches.closeDoc(prevPath);
     }
     path.value = docPath;
+    loading.value = true;
     try {
       const patchesDoc = await patches.openDoc(docPath, options2);
       unsubscribe = setupDoc(patchesDoc);
     } catch (err) {
       baseReturn.error.value = err;
-      baseReturn.loading.value = false;
+      loading.value = false;
     }
   }
   async function close() {
@@ -168,11 +187,11 @@ function usePatchesSync() {
     throw new Error("PatchesSync not found in context. Did you forget to pass sync to providePatchesContext()?");
   }
   const connected = ref(sync.state.connected);
-  const syncing = ref(sync.state.syncing === "updating");
+  const syncing = ref(sync.state.syncStatus === "syncing");
   const online = ref(sync.state.online);
   const unsubscribe = sync.onStateChange((state) => {
     connected.value = state.connected;
-    syncing.value = state.syncing === "updating";
+    syncing.value = state.syncStatus === "syncing";
     online.value = state.online;
   });
   onBeforeUnmount(() => {
@@ -188,12 +207,16 @@ function createDocInjectionKey(name) {
   return Symbol(`patches-doc-${name}`);
 }
 function providePatchesDoc(name, docId, options = {}) {
-  const { patches } = usePatchesContext();
+  const { patches, sync } = 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" });
+  const { setupDoc, baseReturn } = createDocReactiveState({
+    initialLoading: !!autoClose,
+    hasSyncContext: !!sync,
+    changeBehavior: "throw"
+  });
   const currentDocId = ref(unref(docId));
   let unsubscribe = null;
   async function initDoc(id) {

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

@@ -6,5 +6,5 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';

package/dist/vue/index.d.ts

@@ -11,7 +11,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';
 import '../net/PatchesSync.js';
 import '../net/protocol/types.js';

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

@@ -6,7 +6,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';
 
 /**

package/dist/vue/provider.d.ts

@@ -7,7 +7,7 @@ import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';
 import '../net/protocol/types.js';
 import '../net/protocol/JSONRPCClient.js';

package/dist/vue/utils.d.ts

@@ -1 +1,5 @@
 export { areSetsEqual, fillPath } from '../shared/utils.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../json-patch/types.js';

package/package.json

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