@dabble/patches 0.7.8 → 0.7.10

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,9 +178,26 @@ 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.options?.subscribeFilter?.(activeDocIds) || activeDocIds;
+          const subscribeIds = this._filterSubscribeIds(activeDocIds);
           if (subscribeIds.length) {
             await this.ws.subscribe(subscribeIds);
           }
@@ -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);
@@ -212,18 +256,21 @@ class PatchesSync {
           }
         }
       }
+      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 +308,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 +337,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,15 +364,18 @@ 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) {
     const newIds = docIds.filter((id) => !this.trackedDocs.has(id));
     if (!newIds.length) return;
+    const alreadySubscribed = this._getActiveSubscriptions();
     newIds.forEach((id) => this.trackedDocs.add(id));
     for (const docId of newIds) {
       for (const algorithm of Object.values(this.patches.algorithms)) {
@@ -330,13 +388,24 @@ class PatchesSync {
         }
       }
     }
-    let subscribeIds = newIds;
-    if (this.options?.subscribeFilter) {
-      const alreadyTracked = this.options.subscribeFilter([...this.trackedDocs]);
-      subscribeIds = subscribeIds.filter((id) => !alreadyTracked.includes(id));
+    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));
         if (subscribeIds.length) {
           await this.ws.subscribe(subscribeIds);
         }
@@ -350,8 +419,12 @@ class PatchesSync {
   async _handleDocsUntracked(docIds) {
     const existingIds = docIds.filter((id) => this.trackedDocs.has(id));
     if (!existingIds.length) return;
+    const subscribedBefore = this._getActiveSubscriptions();
     existingIds.forEach((id) => this.trackedDocs.delete(id));
-    const unsubscribeIds = this.options?.subscribeFilter?.(existingIds) || existingIds;
+    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) {
       try {
         await this.ws.unsubscribe(unsubscribeIds);
@@ -361,8 +434,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);
   }
   /**
@@ -377,9 +452,68 @@ 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.
+   */
+  _filterSubscribeIds(docIds) {
+    return this.options?.subscribeFilter?.(docIds) || docIds;
+  }
+  /**
+   * Returns the set of doc IDs currently subscribed on the server, derived by
+   * applying the subscribe filter to the full tracked set.
+   */
+  _getActiveSubscriptions() {
+    return new Set(this._filterSubscribeIds([...this.trackedDocs]));
+  }
   /**
    * Helper to detect DOC_DELETED (410) errors from the server.
    */
@@ -392,5 +526,6 @@ __decorateElement(_init, 1, "syncDoc", _syncDoc_dec, PatchesSync);
 __decorateElement(_init, 1, "_receiveCommittedChanges", __receiveCommittedChanges_dec, PatchesSync);
 __decoratorMetadata(_init, PatchesSync);
 export {
-  PatchesSync
+  PatchesSync,
+  isDocLoaded
 };

package/dist/net/index.d.ts

@@ -12,14 +12,15 @@ export { PatchesWebSocket } from './websocket/PatchesWebSocket.js';
 export { JsonRpcMessage, SignalingService } from './websocket/SignalingService.js';
 export { WebSocketServer, WebSocketServerOptions } from './websocket/WebSocketServer.js';
 export { WebSocketOptions, WebSocketTransport } from './websocket/WebSocketTransport.js';
+export { isDocLoaded } from '../shared/utils.js';
 export { CommitChangesOptions } from '../types.js';
 import '../event-signal.js';
 import '../algorithms/ot/shared/changeBatching.js';
-import '../client/Patches.js';
-import '../json-patch/types.js';
 import '../client/ClientAlgorithm.js';
-import '../BaseDoc-_Rsau70J.js';
+import '../json-patch/types.js';
+import '../BaseDoc-BfVJNeCi.js';
 import '../client/PatchesStore.js';
+import '../client/Patches.js';
 import '../server/types.js';
 import '../utils/deferred.js';
 import '../json-patch/JSONPatch.js';

package/dist/net/protocol/JSONRPCServer.js

@@ -54,7 +54,10 @@ class JSONRPCServer {
       this.registerMethod(method, async (...args) => {
         const docId = args[0];
         if (typeof docId !== "string" || !docId) {
-          throw new StatusError(400, `INVALID_REQUEST: docId is required (got ${docId === "" ? "empty string" : String(docId)})`);
+          throw new StatusError(
+            400,
+            `INVALID_REQUEST: docId is required (got ${docId === "" ? "empty string" : String(docId)})`
+          );
         }
         const ctx = getAuthContext();
         await this.assertAccess(access, ctx, method, args);
@@ -137,7 +140,10 @@ class JSONRPCServer {
     if (!this.auth) return;
     const docId = args?.[0];
     if (typeof docId !== "string" || !docId) {
-      throw new StatusError(400, `INVALID_REQUEST: docId is required (got ${docId === "" ? "empty string" : String(docId)})`);
+      throw new StatusError(
+        400,
+        `INVALID_REQUEST: docId is required (got ${docId === "" ? "empty string" : String(docId)})`
+      );
     }
     const ok = await this.auth.canAccess(ctx, docId, access, method);
     if (!ok) {

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';
@@ -16,6 +16,7 @@ import '../net/PatchesClient.js';
 import '../net/websocket/WebSocketTransport.js';
 import '../utils/deferred.js';
 import '../algorithms/ot/shared/changeBatching.js';
+import '../shared/utils.js';
 
 /**
  * Context value containing Patches and optional PatchesSync instances.

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();
@@ -66,7 +79,24 @@ function createDocReactiveState(options) {
     change,
     doc
   };
-  return { doc, setDoc, data, setData, loading, setLoading, error, setError, rev, setRev, hasPending, setHasPending, setupDoc, resetSignals, change, baseReturn };
+  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") {
@@ -75,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) => {
@@ -122,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
   });
@@ -143,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);
@@ -180,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(() => {
@@ -202,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';