@dabble/patches 0.7.1 → 0.7.2

package/dist/client/IndexedDBStore.js

@@ -58,7 +58,7 @@ class IndexedDBStore {
       this.db.close();
       this.db = null;
       this.dbPromise = deferred();
-      this.dbPromise.resolve(null);
+      this.dbPromise.reject(new Error("Store has been closed"));
     }
   }
   async deleteDB() {

package/dist/client/LWWAlgorithm.js

@@ -26,7 +26,7 @@ class LWWAlgorithm {
     const committedRev = doc?.committedRev ?? await this.store.getCommittedRev(docId);
     const changes = [createChange(committedRev, committedRev + 1, timedOps, metadata)];
     if (doc) {
-      doc.applyChanges(changes);
+      doc.applyChanges(changes, true);
     }
     return changes;
   }
@@ -52,7 +52,8 @@ class LWWAlgorithm {
     const localOps = [...sendingChange?.ops ?? [], ...pendingOps];
     const mergedChanges = mergeServerWithLocal(serverChanges, localOps);
     if (doc) {
-      doc.applyChanges(mergedChanges);
+      const hasPending = localOps.length > 0;
+      doc.applyChanges(mergedChanges, hasPending);
     }
     return mergedChanges;
   }

package/dist/client/LWWDoc.d.ts

@@ -49,8 +49,10 @@ declare class LWWDoc<T extends object = object> extends BaseDoc<T> {
      * - `committedAt === 0`: Pending local change (marks hasPending = true)
      *
      * @param changes Array of changes to apply
+     * @param hasPending If provided, overrides the inferred pending state.
+     *   Used by LWWAlgorithm which knows the true pending state from the store.
      */
-    applyChanges(changes: Change[]): void;
+    applyChanges(changes: Change[], hasPending?: boolean): void;
 }
 
 export { LWWDoc };

package/dist/client/LWWDoc.js

@@ -57,8 +57,10 @@ class LWWDoc extends BaseDoc {
    * - `committedAt === 0`: Pending local change (marks hasPending = true)
    *
    * @param changes Array of changes to apply
+   * @param hasPending If provided, overrides the inferred pending state.
+   *   Used by LWWAlgorithm which knows the true pending state from the store.
    */
-  applyChanges(changes) {
+  applyChanges(changes, hasPending) {
     if (changes.length === 0) return;
     for (const change of changes) {
       for (const op of change.ops) {
@@ -75,7 +77,7 @@ class LWWDoc extends BaseDoc {
       }
     }
     this._committedRev = lastCommittedRev;
-    this._hasPending = hasPendingChanges;
+    this._hasPending = hasPending ?? hasPendingChanges;
     this.onUpdate.emit(this._state);
   }
 }

package/dist/client/Patches.d.ts

@@ -50,6 +50,11 @@ declare class Patches {
     /** Emitted when a doc has pending changes ready to send */
     readonly onChange: Signal<(docId: string) => void>;
     constructor(opts: PatchesOptions);
+    /**
+     * Loads tracked docs from all registered algorithm stores.
+     * Extracted as a protected method so subclasses can override initialization behavior.
+     */
+    protected init(): void;
     /**
      * Gets an algorithm by name, throwing if not found.
      */

package/dist/client/Patches.js

@@ -37,8 +37,22 @@ class Patches {
       throw new Error(`Default algorithm '${this.defaultAlgorithm}' not found in algorithms map`);
     }
     this.docOptions = opts.docOptions ?? {};
-    this._getAlgorithm(this.defaultAlgorithm).listDocs().then((docs) => {
-      this.trackDocs(docs.map(({ docId }) => docId));
+    this.init();
+  }
+  /**
+   * Loads tracked docs from all registered algorithm stores.
+   * Extracted as a protected method so subclasses can override initialization behavior.
+   */
+  init() {
+    const algorithms = Object.values(this.algorithms).filter(Boolean);
+    Promise.all(
+      algorithms.map(
+        (algorithm) => algorithm.listDocs().then((docs) => {
+          this.trackDocs(docs.map(({ docId }) => docId));
+        })
+      )
+    ).catch((err) => {
+      console.error("Failed to load tracked docs during initialization:", err);
     });
   }
   /**

package/dist/compression/index.js

@@ -1,10 +1,5 @@
 import "../chunk-IZ2YBCUP.js";
-import {
-  compressToBase64,
-  compressToUint8Array,
-  decompressFromBase64,
-  decompressFromUint8Array
-} from "./lz.js";
+import { compressToBase64, compressToUint8Array, decompressFromBase64, decompressFromUint8Array } from "./lz.js";
 const compressedSizeBase64 = (data) => {
   if (data === void 0) return 0;
   try {

package/dist/net/index.d.ts

@@ -6,7 +6,6 @@ export { AccessLevel, ApiDefinition, ConnectionSignalSubscriber, JSONRPCServer,
 export { getAuthContext, getClientId } from './serverContext.js';
 export { AwarenessUpdateNotificationParams, ClientTransport, ConnectionState, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, ListOptions, Message, PatchesAPI, PatchesNotificationParams, ServerTransport, SignalNotificationParams } from './protocol/types.js';
 export { rpcError, rpcNotification, rpcResponse } from './protocol/utils.js';
-export { PatchesState, SyncingState } from './types.js';
 export { Access, AuthContext, AuthorizationProvider, allowAll, assertNotDeleted, denyAll } from './websocket/AuthorizationProvider.js';
 export { onlineState } from './websocket/onlineState.js';
 export { PatchesWebSocket } from './websocket/PatchesWebSocket.js';

package/dist/net/protocol/JSONRPCServer.js

@@ -152,9 +152,11 @@ class JSONRPCServer {
     }
     const args = Array.isArray(params) ? params : params === void 0 ? [] : [params];
     setAuthContext(ctx);
-    const response = handler(...args);
-    clearAuthContext();
-    return response;
+    try {
+      return await handler(...args);
+    } finally {
+      clearAuthContext();
+    }
   }
 }
 export {

package/dist/net/webrtc/WebRTCAwareness.js

@@ -64,9 +64,8 @@ class WebRTCAwareness {
    * @param value - The new local awareness state to set and broadcast
    */
   set localState(value) {
-    value.id = this.myId;
-    this._localState = value;
-    this.transport.send(JSON.stringify(value));
+    this._localState = { ...value, id: this.myId };
+    this.transport.send(JSON.stringify(this._localState));
   }
   /**
    * Handles a new peer connection by sending the local state to the new peer.

package/dist/net/websocket/WebSocketTransport.js

@@ -169,9 +169,12 @@ class WebSocketTransport {
     if (!this.onlineUnsubscriber) {
       this.onlineUnsubscriber = onlineState.onOnlineChange((isOnline) => {
         if (isOnline && this.shouldBeConnected && !this.connecting && this.state !== "connected") {
-          const { resolve, reject } = this.connectionDeferred;
+          const oldDeferred = this.connectionDeferred;
           this.connectionDeferred = null;
-          this.connect().then(resolve, reject);
+          const connectPromise = this.connect();
+          if (oldDeferred) {
+            connectPromise.then(oldDeferred.resolve, oldDeferred.reject);
+          }
         } else if (!isOnline && this.ws) {
           this.ws.close();
         }

package/dist/server/OTServer.js

@@ -127,8 +127,7 @@ class OTServer {
   async captureCurrentVersion(docId, metadata) {
     assertVersionMetadata(metadata);
     const { state: initialState, changes } = await getSnapshotAtRevision(this.store, docId);
-    let state = initialState;
-    state = applyChanges(state, changes);
+    const state = applyChanges(initialState, changes);
     const version = await createVersion(this.store, docId, state, changes, metadata);
     if (!version) {
       return null;

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

@@ -0,0 +1,89 @@
+import { Patches } from '../client/Patches.js';
+import { a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
+import '../event-signal.js';
+import '../json-patch/types.js';
+import '../types.js';
+import '../json-patch/JSONPatch.js';
+import '@dabble/delta';
+import '../client/ClientAlgorithm.js';
+import '../client/PatchesStore.js';
+
+/**
+ * Reference counting manager for PatchesDoc instances.
+ *
+ * Tracks how many components are using each document and only opens/closes
+ * documents when the reference count goes to/from zero.
+ *
+ * This prevents the footgun where multiple components open the same doc but the
+ * first one to unmount closes it for everyone else.
+ */
+declare class DocManager {
+    private refCounts;
+    private pendingOps;
+    /**
+     * Opens a document with reference counting.
+     *
+     * - If this is the first reference, calls patches.openDoc()
+     * - If doc is already open, returns existing instance and increments count
+     * - Handles concurrent opens to the same doc safely
+     *
+     * @param patches - Patches instance
+     * @param docId - Document ID to open
+     * @returns Promise resolving to PatchesDoc instance
+     */
+    openDoc<T extends object>(patches: Patches, docId: string): Promise<PatchesDoc<T>>;
+    /**
+     * Closes a document with reference counting.
+     *
+     * - Decrements the reference count
+     * - Only calls patches.closeDoc() when count reaches zero
+     * - Safe to call even if doc was never opened
+     *
+     * @param patches - Patches instance
+     * @param docId - Document ID to close
+     * @param untrack - Whether to also untrack the doc when closing (default: false)
+     */
+    closeDoc(patches: Patches, docId: string, untrack?: boolean): Promise<void>;
+    /**
+     * Increments the reference count for a document without opening it.
+     *
+     * Used in explicit mode to track usage and prevent premature closes
+     * from autoClose mode.
+     *
+     * @param docId - Document ID
+     */
+    incrementRefCount(docId: string): void;
+    /**
+     * Decrements the reference count for a document without closing it.
+     *
+     * Used in explicit mode to release usage tracking.
+     *
+     * @param docId - Document ID
+     */
+    decrementRefCount(docId: string): void;
+    /**
+     * Gets the current reference count for a document.
+     *
+     * Useful for debugging or advanced use cases.
+     *
+     * @param docId - Document ID
+     * @returns Current reference count (0 if not tracked)
+     */
+    getRefCount(docId: string): number;
+    /**
+     * Clears all reference counts without closing documents.
+     *
+     * Use with caution - this is mainly for testing or cleanup scenarios
+     * where you want to reset the manager state.
+     */
+    reset(): void;
+}
+/**
+ * Gets or creates a DocManager for a Patches instance.
+ *
+ * @param patches - Patches instance
+ * @returns DocManager for this Patches instance
+ */
+declare function getDocManager(patches: Patches): DocManager;
+
+export { DocManager, getDocManager };

package/dist/shared/doc-manager.js

@@ -0,0 +1,126 @@
+import "../chunk-IZ2YBCUP.js";
+class DocManager {
+  refCounts = /* @__PURE__ */ new Map();
+  pendingOps = /* @__PURE__ */ new Map();
+  /**
+   * Opens a document with reference counting.
+   *
+   * - If this is the first reference, calls patches.openDoc()
+   * - If doc is already open, returns existing instance and increments count
+   * - Handles concurrent opens to the same doc safely
+   *
+   * @param patches - Patches instance
+   * @param docId - Document ID to open
+   * @returns Promise resolving to PatchesDoc instance
+   */
+  async openDoc(patches, docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount === 0 && this.pendingOps.has(docId)) {
+      const doc = await this.pendingOps.get(docId);
+      this.refCounts.set(docId, (this.refCounts.get(docId) || 0) + 1);
+      return doc;
+    }
+    if (currentCount > 0) {
+      this.refCounts.set(docId, currentCount + 1);
+      const doc = patches.getOpenDoc(docId);
+      if (!doc) {
+        throw new Error(`Document ${docId} has ref count ${currentCount} but is not open in Patches`);
+      }
+      return doc;
+    }
+    const openPromise = patches.openDoc(docId);
+    this.pendingOps.set(docId, openPromise);
+    try {
+      const doc = await openPromise;
+      this.refCounts.set(docId, 1);
+      return doc;
+    } catch (error) {
+      this.refCounts.delete(docId);
+      throw error;
+    } finally {
+      this.pendingOps.delete(docId);
+    }
+  }
+  /**
+   * Closes a document with reference counting.
+   *
+   * - Decrements the reference count
+   * - Only calls patches.closeDoc() when count reaches zero
+   * - Safe to call even if doc was never opened
+   *
+   * @param patches - Patches instance
+   * @param docId - Document ID to close
+   * @param untrack - Whether to also untrack the doc when closing (default: false)
+   */
+  async closeDoc(patches, docId, untrack = false) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount === 0) {
+      return;
+    }
+    if (currentCount === 1) {
+      this.refCounts.delete(docId);
+      await patches.closeDoc(docId, { untrack });
+    } else {
+      this.refCounts.set(docId, currentCount - 1);
+    }
+  }
+  /**
+   * Increments the reference count for a document without opening it.
+   *
+   * Used in explicit mode to track usage and prevent premature closes
+   * from autoClose mode.
+   *
+   * @param docId - Document ID
+   */
+  incrementRefCount(docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    this.refCounts.set(docId, currentCount + 1);
+  }
+  /**
+   * Decrements the reference count for a document without closing it.
+   *
+   * Used in explicit mode to release usage tracking.
+   *
+   * @param docId - Document ID
+   */
+  decrementRefCount(docId) {
+    const currentCount = this.refCounts.get(docId) || 0;
+    if (currentCount > 0) {
+      this.refCounts.set(docId, currentCount - 1);
+    }
+  }
+  /**
+   * Gets the current reference count for a document.
+   *
+   * Useful for debugging or advanced use cases.
+   *
+   * @param docId - Document ID
+   * @returns Current reference count (0 if not tracked)
+   */
+  getRefCount(docId) {
+    return this.refCounts.get(docId) || 0;
+  }
+  /**
+   * Clears all reference counts without closing documents.
+   *
+   * Use with caution - this is mainly for testing or cleanup scenarios
+   * where you want to reset the manager state.
+   */
+  reset() {
+    this.refCounts.clear();
+    this.pendingOps.clear();
+  }
+}
+const managers = /* @__PURE__ */ new WeakMap();
+function getDocManager(patches) {
+  let manager = managers.get(patches);
+  if (!manager) {
+    manager = new DocManager();
+    managers.set(patches, manager);
+  }
+  return manager;
+}
+export {
+  DocManager,
+  getDocManager
+};

package/dist/shared/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolves a path template by replacing `:param` placeholders with values.
+ *
+ * @example
+ * ```typescript
+ * fillPath('projects/:projectId/content', { projectId: 'abc' })
+ * // => 'projects/abc/content'
+ * ```
+ *
+ * @param template - Path template with `:param` placeholders
+ * @param params - Object mapping parameter names to values
+ * @returns Resolved path string
+ * @throws Error if a parameter in the template is missing from params
+ */
+declare function fillPath(template: string, params: Record<string, string>): string;
+/**
+ * Compares two sets for equality.
+ * @internal
+ */
+declare function areSetsEqual(a: Set<string>, b: Set<string>): boolean;
+
+export { areSetsEqual, fillPath };

package/dist/shared/utils.js

@@ -0,0 +1,22 @@
+import "../chunk-IZ2YBCUP.js";
+function fillPath(template, params) {
+  return template.replace(/:(\w+)/g, (match, name) => {
+    const value = params[name];
+    if (value == null) {
+      throw new Error(`Missing parameter ":${name}" for path "${template}"`);
+    }
+    return value;
+  });
+}
+function areSetsEqual(a, b) {
+  if (a === b) return true;
+  if (a.size !== b.size) return false;
+  for (const item of a) {
+    if (!b.has(item)) return false;
+  }
+  return true;
+}
+export {
+  areSetsEqual,
+  fillPath
+};

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

@@ -1,88 +1,10 @@
-import { Patches } from '../client/Patches.js';
-import { a as PatchesDoc } from '../BaseDoc-DkP3tUhT.js';
+export { DocManager, getDocManager } from '../shared/doc-manager.js';
+import '../client/Patches.js';
 import '../event-signal.js';
 import '../json-patch/types.js';
 import '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../client/ClientAlgorithm.js';
+import '../BaseDoc-DkP3tUhT.js';
 import '../client/PatchesStore.js';
-
-/**
- * Reference counting manager for PatchesDoc instances.
- *
- * Tracks how many Solid components are using each document and only opens/closes
- * documents when the reference count goes to/from zero.
- *
- * This prevents the footgun where multiple components open the same doc but the
- * first one to unmount closes it for everyone else.
- */
-declare class DocManager {
-    private refCounts;
-    private pendingOps;
-    /**
-     * Opens a document with reference counting.
-     *
-     * - If this is the first reference, calls patches.openDoc()
-     * - If doc is already open, returns existing instance and increments count
-     * - Handles concurrent opens to the same doc safely
-     *
-     * @param patches - Patches instance
-     * @param docId - Document ID to open
-     * @returns Promise resolving to PatchesDoc instance
-     */
-    openDoc<T extends object>(patches: Patches, docId: string): Promise<PatchesDoc<T>>;
-    /**
-     * Closes a document with reference counting.
-     *
-     * - Decrements the reference count
-     * - Only calls patches.closeDoc() when count reaches zero
-     * - Safe to call even if doc was never opened
-     *
-     * @param patches - Patches instance
-     * @param docId - Document ID to close
-     */
-    closeDoc(patches: Patches, docId: string): Promise<void>;
-    /**
-     * Increments the reference count for a document without opening it.
-     *
-     * Used in explicit mode to track usage and prevent premature closes
-     * from autoClose mode.
-     *
-     * @param docId - Document ID
-     */
-    incrementRefCount(docId: string): void;
-    /**
-     * Decrements the reference count for a document without closing it.
-     *
-     * Used in explicit mode to release usage tracking.
-     *
-     * @param docId - Document ID
-     */
-    decrementRefCount(docId: string): void;
-    /**
-     * Gets the current reference count for a document.
-     *
-     * Useful for debugging or advanced use cases.
-     *
-     * @param docId - Document ID
-     * @returns Current reference count (0 if not tracked)
-     */
-    getRefCount(docId: string): number;
-    /**
-     * Clears all reference counts without closing documents.
-     *
-     * Use with caution - this is mainly for testing or cleanup scenarios
-     * where you want to reset the manager state.
-     */
-    reset(): void;
-}
-/**
- * Gets or creates a DocManager for a Patches instance.
- *
- * @param patches - Patches instance
- * @returns DocManager for this Patches instance
- */
-declare function getDocManager(patches: Patches): DocManager;
-
-export { DocManager, getDocManager };

package/dist/solid/doc-manager.js

@@ -1,124 +1,5 @@
 import "../chunk-IZ2YBCUP.js";
-class DocManager {
-  refCounts = /* @__PURE__ */ new Map();
-  pendingOps = /* @__PURE__ */ new Map();
-  /**
-   * Opens a document with reference counting.
-   *
-   * - If this is the first reference, calls patches.openDoc()
-   * - If doc is already open, returns existing instance and increments count
-   * - Handles concurrent opens to the same doc safely
-   *
-   * @param patches - Patches instance
-   * @param docId - Document ID to open
-   * @returns Promise resolving to PatchesDoc instance
-   */
-  async openDoc(patches, docId) {
-    const currentCount = this.refCounts.get(docId) || 0;
-    if (currentCount === 0 && this.pendingOps.has(docId)) {
-      const doc = await this.pendingOps.get(docId);
-      this.refCounts.set(docId, (this.refCounts.get(docId) || 0) + 1);
-      return doc;
-    }
-    if (currentCount > 0) {
-      this.refCounts.set(docId, currentCount + 1);
-      const doc = patches.getOpenDoc(docId);
-      if (!doc) {
-        throw new Error(`Document ${docId} has ref count ${currentCount} but is not open in Patches`);
-      }
-      return doc;
-    }
-    const openPromise = patches.openDoc(docId);
-    this.pendingOps.set(docId, openPromise);
-    try {
-      const doc = await openPromise;
-      this.refCounts.set(docId, 1);
-      return doc;
-    } catch (error) {
-      this.refCounts.delete(docId);
-      throw error;
-    } finally {
-      this.pendingOps.delete(docId);
-    }
-  }
-  /**
-   * Closes a document with reference counting.
-   *
-   * - Decrements the reference count
-   * - Only calls patches.closeDoc() when count reaches zero
-   * - Safe to call even if doc was never opened
-   *
-   * @param patches - Patches instance
-   * @param docId - Document ID to close
-   */
-  async closeDoc(patches, docId) {
-    const currentCount = this.refCounts.get(docId) || 0;
-    if (currentCount === 0) {
-      return;
-    }
-    if (currentCount === 1) {
-      this.refCounts.delete(docId);
-      await patches.closeDoc(docId, { untrack: true });
-    } else {
-      this.refCounts.set(docId, currentCount - 1);
-    }
-  }
-  /**
-   * Increments the reference count for a document without opening it.
-   *
-   * Used in explicit mode to track usage and prevent premature closes
-   * from autoClose mode.
-   *
-   * @param docId - Document ID
-   */
-  incrementRefCount(docId) {
-    const currentCount = this.refCounts.get(docId) || 0;
-    this.refCounts.set(docId, currentCount + 1);
-  }
-  /**
-   * Decrements the reference count for a document without closing it.
-   *
-   * Used in explicit mode to release usage tracking.
-   *
-   * @param docId - Document ID
-   */
-  decrementRefCount(docId) {
-    const currentCount = this.refCounts.get(docId) || 0;
-    if (currentCount > 0) {
-      this.refCounts.set(docId, currentCount - 1);
-    }
-  }
-  /**
-   * Gets the current reference count for a document.
-   *
-   * Useful for debugging or advanced use cases.
-   *
-   * @param docId - Document ID
-   * @returns Current reference count (0 if not tracked)
-   */
-  getRefCount(docId) {
-    return this.refCounts.get(docId) || 0;
-  }
-  /**
-   * Clears all reference counts without closing documents.
-   *
-   * Use with caution - this is mainly for testing or cleanup scenarios
-   * where you want to reset the manager state.
-   */
-  reset() {
-    this.refCounts.clear();
-    this.pendingOps.clear();
-  }
-}
-const managers = /* @__PURE__ */ new WeakMap();
-function getDocManager(patches) {
-  let manager = managers.get(patches);
-  if (!manager) {
-    manager = new DocManager();
-    managers.set(patches, manager);
-  }
-  return manager;
-}
+import { DocManager, getDocManager } from "../shared/doc-manager.js";
 export {
   DocManager,
   getDocManager

package/dist/solid/index.d.ts

@@ -1,6 +1,8 @@
 export { PatchesContextValue, PatchesProvider, PatchesProviderProps, usePatchesContext } from './context.js';
-export { MaybeAccessor, UsePatchesDocOptions, UsePatchesDocReturn, UsePatchesSyncReturn, createPatchesDoc, usePatchesDoc, usePatchesSync } from './primitives.js';
-export { DocManager, getDocManager } from './doc-manager.js';
+export { MaybeAccessor, PatchesDocProviderProps, UsePatchesDocLazyOptions, UsePatchesDocLazyReturn, UsePatchesDocOptions, UsePatchesDocReturn, UsePatchesSyncReturn, createPatchesDoc, usePatchesDoc, usePatchesSync } from './primitives.js';
+export { CreateManagedDocsOptions, CreateManagedDocsReturn, createManagedDocs } from './managed-docs.js';
+export { fillPath } from '../shared/utils.js';
+export { DocManager, getDocManager } from '../shared/doc-manager.js';
 import 'solid-js';
 import '../client/Patches.js';
 import '../event-signal.js';