@automerge/automerge-repo 2.0.0-alpha.20 → 2.0.0-alpha.23

package/dist/Repo.js

@@ -9,6 +9,7 @@ import { throttle } from "./helpers/throttle.js";
 import { NetworkSubsystem } from "./network/NetworkSubsystem.js";
 import { StorageSubsystem } from "./storage/StorageSubsystem.js";
 import { CollectionSynchronizer } from "./synchronizer/CollectionSynchronizer.js";
+import { abortable } from "./helpers/abortable.js";
 function randomPeerId() {
     return ("peer-" + Math.random().toString(36).slice(4));
 }
@@ -170,16 +171,8 @@ export class Repo extends EventEmitter {
             };
             handle.on("heads-changed", throttle(saveFn, this.saveDebounceRate));
         }
-        handle.on("unavailable", () => {
-            this.#log("document unavailable", { documentId: handle.documentId });
-            this.emit("unavailable-document", {
-                documentId: handle.documentId,
-            });
-        });
         // Register the document with the synchronizer. This advertises our interest in the document.
-        this.synchronizer.addDocument(handle.documentId);
-        // Preserve the old event in case anyone was using it.
-        this.emit("document", { handle });
+        this.synchronizer.addDocument(handle);
     }
     #receiveMessage(message) {
         switch (message.type) {
@@ -280,18 +273,13 @@ export class Repo extends EventEmitter {
      * Any peers this `Repo` is connected to for whom `sharePolicy` returns `true` will
      * be notified of the newly created DocHandle.
      *
-     * @throws if the cloned handle is not yet ready or if
-     * `clonedHandle.docSync()` returns `undefined` (i.e. the handle is unavailable).
      */
     clone(clonedHandle) {
         if (!clonedHandle.isReady()) {
             throw new Error(`Cloned handle is not yet in ready state.
         (Try await handle.whenReady() first.)`);
         }
-        const sourceDoc = clonedHandle.docSync();
-        if (!sourceDoc) {
-            throw new Error("Cloned handle doesn't have a document.");
-        }
+        const sourceDoc = clonedHandle.doc();
         const handle = this.create();
         handle.update(() => {
             // we replace the document with the new cloned one
@@ -299,58 +287,171 @@ export class Repo extends EventEmitter {
         });
         return handle;
     }
-    /**
-     * Retrieves a document by id. It gets data from the local system, but also emits a `document`
-     * event to advertise interest in the document.
-     */
-    find(
-    /** The url or documentId of the handle to retrieve */
-    id) {
+    findWithProgress(id, options = {}) {
+        const { signal } = options;
+        const abortPromise = abortable(signal);
         const { documentId, heads } = isValidAutomergeUrl(id)
             ? parseAutomergeUrl(id)
             : { documentId: interpretAsDocumentId(id), heads: undefined };
-        const cachedHandle = this.#handleCache[documentId];
-        if (cachedHandle) {
-            if (cachedHandle.isUnavailable()) {
-                // this ensures that the event fires after the handle has been returned
-                setTimeout(() => {
-                    cachedHandle.emit("unavailable", {
-                        handle: cachedHandle,
-                    });
-                });
+        // Check cache first - return plain FindStep for terminal states
+        if (this.#handleCache[documentId]) {
+            const handle = this.#handleCache[documentId];
+            if (handle.state === UNAVAILABLE) {
+                const result = {
+                    state: "unavailable",
+                    error: new Error(`Document ${id} is unavailable`),
+                    handle,
+                };
+                return result;
+            }
+            if (handle.state === DELETED) {
+                return {
+                    state: "failed",
+                    error: new Error(`Document ${id} was deleted`),
+                    handle,
+                };
+            }
+            if (handle.state === READY) {
+                // If we already have the handle, return it immediately (or a view of the handle if heads are specified)
+                return {
+                    state: "ready",
+                    // TODO: this handle needs to be cached (or at least avoid running clone)
+                    handle: heads ? handle.view(heads) : handle,
+                };
             }
-            // If we already have the handle, return it immediately (or a view of the handle if heads are specified)
-            return heads ? cachedHandle.view(heads) : cachedHandle;
         }
-        // If we don't already have the handle, make an empty one and try loading it
-        const handle = this.#getHandle({
-            documentId,
-        });
-        // Loading & network is going to be asynchronous no matter what,
-        // but we want to return the handle immediately.
-        const attemptLoad = this.storageSubsystem
-            ? this.storageSubsystem.loadDoc(handle.documentId)
-            : Promise.resolve(null);
-        attemptLoad
-            .then(async (loadedDoc) => {
-            if (loadedDoc) {
-                // uhhhh, sorry if you're reading this because we were lying to the type system
-                handle.update(() => loadedDoc);
-                handle.doneLoading();
+        // the generator takes over `this`, so we need an alias to the repo this
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const that = this;
+        async function* progressGenerator() {
+            try {
+                const handle = that.#getHandle({ documentId });
+                yield { state: "loading", progress: 25, handle };
+                const loadingPromise = await (that.storageSubsystem
+                    ? that.storageSubsystem.loadDoc(handle.documentId)
+                    : Promise.resolve(null));
+                const loadedDoc = await Promise.race([loadingPromise, abortPromise]);
+                if (loadedDoc) {
+                    handle.update(() => loadedDoc);
+                    handle.doneLoading();
+                    yield { state: "loading", progress: 50, handle };
+                }
+                else {
+                    await Promise.race([that.networkSubsystem.whenReady(), abortPromise]);
+                    handle.request();
+                    yield { state: "loading", progress: 75, handle };
+                }
+                that.#registerHandleWithSubsystems(handle);
+                await Promise.race([
+                    handle.whenReady([READY, UNAVAILABLE]),
+                    abortPromise,
+                ]);
+                if (handle.state === UNAVAILABLE) {
+                    yield { state: "unavailable", handle };
+                }
+                if (handle.state === DELETED) {
+                    throw new Error(`Document ${id} was deleted`);
+                }
+                yield { state: "ready", handle };
             }
-            else {
-                // we want to wait for the network subsystem to be ready before
-                // we request the document. this prevents entering unavailable during initialization.
-                await this.networkSubsystem.whenReady();
-                handle.request();
+            catch (error) {
+                yield {
+                    state: "failed",
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    handle,
+                };
             }
-            this.#registerHandleWithSubsystems(handle);
-        })
-            .catch(err => {
-            this.#log("error waiting for network", { err });
-        });
-        // If we already have the handle, return it immediately (or a view of the handle if heads are specified)
-        return heads ? handle.view(heads) : handle;
+        }
+        const iterator = progressGenerator();
+        const next = async () => {
+            const result = await iterator.next();
+            return { ...result.value, next };
+        };
+        const untilReady = async (allowableStates) => {
+            for await (const state of iterator) {
+                if (allowableStates.includes(state.handle.state)) {
+                    return state.handle;
+                }
+                if (state.state === "unavailable") {
+                    throw new Error(`Document ${id} is unavailable`);
+                }
+                if (state.state === "ready")
+                    return state.handle;
+                if (state.state === "failed")
+                    throw state.error;
+            }
+            throw new Error("Iterator completed without reaching ready state");
+        };
+        const handle = this.#getHandle({ documentId });
+        const initial = { state: "loading", progress: 0, handle };
+        return { ...initial, next, untilReady };
+    }
+    async find(id, options = {}) {
+        const { allowableStates = ["ready"], signal } = options;
+        const progress = this.findWithProgress(id, { signal });
+        /*if (allowableStates.includes(progress.state)) {
+          console.log("returning early")
+          return progress.handle
+        }*/
+        if ("untilReady" in progress) {
+            this.#registerHandleWithSubsystems(progress.handle);
+            return progress.untilReady(allowableStates);
+        }
+        else {
+            return progress.handle;
+        }
+    }
+    /**
+     * Loads a document without waiting for ready state
+     */
+    async #loadDocument(documentId) {
+        // If we have the handle cached, return it
+        if (this.#handleCache[documentId]) {
+            return this.#handleCache[documentId];
+        }
+        // If we don't already have the handle, make an empty one and try loading it
+        const handle = this.#getHandle({ documentId });
+        const loadedDoc = await (this.storageSubsystem
+            ? this.storageSubsystem.loadDoc(handle.documentId)
+            : Promise.resolve(null));
+        if (loadedDoc) {
+            // We need to cast this to <T> because loadDoc operates in <unknowns>.
+            // This is really where we ought to be validating the input matches <T>.
+            handle.update(() => loadedDoc);
+            handle.doneLoading();
+        }
+        else {
+            // Because the network subsystem might still be booting up, we wait
+            // here so that we don't immediately give up loading because we're still
+            // making our initial connection to a sync server.
+            await this.networkSubsystem.whenReady();
+            handle.request();
+        }
+        this.#registerHandleWithSubsystems(handle);
+        return handle;
+    }
+    /**
+     * Retrieves a document by id. It gets data from the local system, but also emits a `document`
+     * event to advertise interest in the document.
+     */
+    async findClassic(
+    /** The url or documentId of the handle to retrieve */
+    id, options = {}) {
+        const documentId = interpretAsDocumentId(id);
+        const { allowableStates, signal } = options;
+        return Promise.race([
+            (async () => {
+                const handle = await this.#loadDocument(documentId);
+                if (!allowableStates) {
+                    await handle.whenReady([READY, UNAVAILABLE]);
+                    if (handle.state === UNAVAILABLE && !signal?.aborted) {
+                        throw new Error(`Document ${id} is unavailable`);
+                    }
+                }
+                return handle;
+            })(),
+            abortable(signal),
+        ]);
     }
     delete(
     /** The url or documentId of the handle to delete */
@@ -371,9 +472,7 @@ export class Repo extends EventEmitter {
     async export(id) {
         const documentId = interpretAsDocumentId(id);
         const handle = this.#getHandle({ documentId });
-        const doc = await handle.doc();
-        if (!doc)
-            return undefined;
+        const doc = handle.doc();
         return Automerge.save(doc);
     }
     /**
@@ -419,11 +518,7 @@ export class Repo extends EventEmitter {
             ? documents.map(id => this.#handleCache[id])
             : Object.values(this.#handleCache);
         await Promise.all(handles.map(async (handle) => {
-            const doc = handle.docSync();
-            if (!doc) {
-                return;
-            }
-            return this.storageSubsystem.saveDoc(handle.documentId, doc);
+            return this.storageSubsystem.saveDoc(handle.documentId, handle.doc());
         }));
     }
     /**
@@ -438,7 +533,9 @@ export class Repo extends EventEmitter {
             return;
         }
         const handle = this.#getHandle({ documentId });
-        const doc = await handle.doc([READY, UNLOADED, DELETED, UNAVAILABLE]);
+        await handle.whenReady([READY, UNLOADED, DELETED, UNAVAILABLE]);
+        const doc = handle.doc();
+        // because this is an internal-ish function, we'll be extra careful about undefined docs here
         if (doc) {
             if (handle.isReady()) {
                 handle.unload();

package/dist/helpers/abortable.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Creates a promise that rejects when the signal is aborted.
+ *
+ * @remarks
+ * This utility creates a promise that rejects when the provided AbortSignal is aborted.
+ * It's designed to be used with Promise.race() to make operations abortable.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ *
+ * try {
+ *   const result = await Promise.race([
+ *     fetch('https://api.example.com/data'),
+ *     abortable(controller.signal)
+ *   ]);
+ * } catch (err) {
+ *   if (err.name === 'AbortError') {
+ *     console.log('The operation was aborted');
+ *   }
+ * }
+ *
+ * // Later, to abort:
+ * controller.abort();
+ * ```
+ *
+ * @param signal - An AbortSignal that can be used to abort the operation
+ * @param cleanup - Optional cleanup function that will be called if aborted
+ * @returns A promise that rejects with AbortError when the signal is aborted
+ * @throws {DOMException} With name "AbortError" when aborted
+ */
+export declare function abortable(signal?: AbortSignal, cleanup?: () => void): Promise<never>;
+/**
+ * Include this type in an options object to pass an AbortSignal to a function.
+ */
+export interface AbortOptions {
+    signal?: AbortSignal;
+}
+//# sourceMappingURL=abortable.d.ts.map

package/dist/helpers/abortable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortable.d.ts","sourceRoot":"","sources":["../../src/helpers/abortable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,SAAS,CACvB,MAAM,CAAC,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,MAAM,IAAI,GACnB,OAAO,CAAC,KAAK,CAAC,CAmBhB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB"}

package/dist/helpers/abortable.js

@@ -0,0 +1,45 @@
+/**
+ * Creates a promise that rejects when the signal is aborted.
+ *
+ * @remarks
+ * This utility creates a promise that rejects when the provided AbortSignal is aborted.
+ * It's designed to be used with Promise.race() to make operations abortable.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ *
+ * try {
+ *   const result = await Promise.race([
+ *     fetch('https://api.example.com/data'),
+ *     abortable(controller.signal)
+ *   ]);
+ * } catch (err) {
+ *   if (err.name === 'AbortError') {
+ *     console.log('The operation was aborted');
+ *   }
+ * }
+ *
+ * // Later, to abort:
+ * controller.abort();
+ * ```
+ *
+ * @param signal - An AbortSignal that can be used to abort the operation
+ * @param cleanup - Optional cleanup function that will be called if aborted
+ * @returns A promise that rejects with AbortError when the signal is aborted
+ * @throws {DOMException} With name "AbortError" when aborted
+ */
+export function abortable(signal, cleanup) {
+    if (signal?.aborted) {
+        throw new DOMException("Operation aborted", "AbortError");
+    }
+    if (!signal) {
+        return new Promise(() => { }); // Never resolves
+    }
+    return new Promise((_, reject) => {
+        signal.addEventListener("abort", () => {
+            cleanup?.();
+            reject(new DOMException("Operation aborted", "AbortError"));
+        }, { once: true });
+    });
+}

package/dist/helpers/tests/network-adapter-tests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network-adapter-tests.d.ts","sourceRoot":"","sources":["../../../src/helpers/tests/network-adapter-tests.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAA;AAIvF;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CA0Q5E;AAID,KAAK,OAAO,GAAG,uBAAuB,GAAG,uBAAuB,EAAE,CAAA;AAElE,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC;IAClC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;IACrC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,CAAC,CAAA"}
+{"version":3,"file":"network-adapter-tests.d.ts","sourceRoot":"","sources":["../../../src/helpers/tests/network-adapter-tests.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAA;AAIvF;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CA2Q5E;AAID,KAAK,OAAO,GAAG,uBAAuB,GAAG,uBAAuB,EAAE,CAAA;AAElE,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC;IAClC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,CAAA;IACrC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,CAAC,CAAA"}

package/dist/helpers/tests/network-adapter-tests.js

@@ -30,23 +30,23 @@ export function runNetworkAdapterTests(_setup, title) {
                 const bobRepo = new Repo({ network: b, peerId: bob });
                 // Alice creates a document
                 const aliceHandle = aliceRepo.create();
-                // Bob receives the document
-                await eventPromise(bobRepo, "document");
-                const bobHandle = bobRepo.find(aliceHandle.url);
+                // TODO: ... let connections complete. this shouldn't be necessary.
+                await pause(50);
+                const bobHandle = await bobRepo.find(aliceHandle.url);
                 // Alice changes the document
                 aliceHandle.change(d => {
                     d.foo = "bar";
                 });
                 // Bob receives the change
                 await eventPromise(bobHandle, "change");
-                assert.equal((await bobHandle.doc())?.foo, "bar");
+                assert.equal((await bobHandle).doc()?.foo, "bar");
                 // Bob changes the document
                 bobHandle.change(d => {
                     d.foo = "baz";
                 });
                 // Alice receives the change
                 await eventPromise(aliceHandle, "change");
-                assert.equal((await aliceHandle.doc())?.foo, "baz");
+                assert.equal(aliceHandle.doc().foo, "baz");
             };
             // Run the test in both directions, in case they're different types of adapters
             {
@@ -72,25 +72,25 @@ export function runNetworkAdapterTests(_setup, title) {
             const aliceHandle = aliceRepo.create();
             const docUrl = aliceHandle.url;
             // Bob and Charlie receive the document
-            await eventPromises([bobRepo, charlieRepo], "document");
-            const bobHandle = bobRepo.find(docUrl);
-            const charlieHandle = charlieRepo.find(docUrl);
+            await pause(50);
+            const bobHandle = await bobRepo.find(docUrl);
+            const charlieHandle = await charlieRepo.find(docUrl);
             // Alice changes the document
             aliceHandle.change(d => {
                 d.foo = "bar";
             });
             // Bob and Charlie receive the change
             await eventPromises([bobHandle, charlieHandle], "change");
-            assert.equal((await bobHandle.doc())?.foo, "bar");
-            assert.equal((await charlieHandle.doc())?.foo, "bar");
+            assert.equal(bobHandle.doc().foo, "bar");
+            assert.equal(charlieHandle.doc().foo, "bar");
             // Charlie changes the document
             charlieHandle.change(d => {
                 d.foo = "baz";
             });
             // Alice and Bob receive the change
             await eventPromises([aliceHandle, bobHandle], "change");
-            assert.equal((await bobHandle.doc())?.foo, "baz");
-            assert.equal((await charlieHandle.doc())?.foo, "baz");
+            assert.equal(bobHandle.doc().foo, "baz");
+            assert.equal(charlieHandle.doc().foo, "baz");
             teardown();
         });
         it("can broadcast a message", async () => {
@@ -101,7 +101,7 @@ export function runNetworkAdapterTests(_setup, title) {
             const charlieRepo = new Repo({ network: c, peerId: charlie });
             await eventPromises([aliceRepo, bobRepo, charlieRepo].map(r => r.networkSubsystem), "peer");
             const aliceHandle = aliceRepo.create();
-            const charlieHandle = charlieRepo.find(aliceHandle.url);
+            const charlieHandle = await charlieRepo.find(aliceHandle.url);
             // pause to give charlie a chance to let alice know it wants the doc
             await pause(100);
             const alicePresenceData = { presence: "alice" };

package/dist/synchronizer/CollectionSynchronizer.d.ts

@@ -1,3 +1,4 @@
+import { DocHandle } from "../DocHandle.js";
 import { Repo } from "../Repo.js";
 import { DocMessage } from "../network/messages.js";
 import { AutomergeUrl, DocumentId, PeerId } from "../types.js";
@@ -19,7 +20,7 @@ export declare class CollectionSynchronizer extends Synchronizer {
     /**
      * Starts synchronizing the given document with all peers that we share it generously with.
      */
-    addDocument(documentId: DocumentId): void;
+    addDocument(handle: DocHandle<unknown>): void;
     removeDocument(documentId: DocumentId): void;
     /** Adds a peer and maybe starts synchronizing with them */
     addPeer(peerId: PeerId): void;

package/dist/synchronizer/CollectionSynchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CollectionSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/CollectionSynchronizer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIhD,4FAA4F;AAC5F,qBAAa,sBAAuB,SAAQ,YAAY;;IAa1C,OAAO,CAAC,IAAI;IATxB,kDAAkD;IAClD,cAAc;IACd,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAK;gBAOtC,IAAI,EAAE,IAAI,EAAE,QAAQ,GAAE,YAAY,EAAO;IAuD7D;;;OAGG;IACG,cAAc,CAAC,OAAO,EAAE,UAAU;IAsCxC;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,UAAU;IAalC,cAAc,CAAC,UAAU,EAAE,UAAU;IAIrC,2DAA2D;IAC3D,OAAO,CAAC,MAAM,EAAE,MAAM;IAgBtB,uDAAuD;IACvD,UAAU,CAAC,MAAM,EAAE,MAAM;IASzB,+CAA+C;IAC/C,IAAI,KAAK,IAAI,MAAM,EAAE,CAEpB;IAED,OAAO,IAAI;QACT,CAAC,GAAG,EAAE,MAAM,GAAG;YACb,KAAK,EAAE,MAAM,EAAE,CAAA;YACf,IAAI,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAC;gBAAC,UAAU,EAAE,MAAM,CAAA;aAAE,CAAA;SAC7C,CAAA;KACF;CASF"}
+{"version":3,"file":"CollectionSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/CollectionSynchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIhD,4FAA4F;AAC5F,qBAAa,sBAAuB,SAAQ,YAAY;;IAa1C,OAAO,CAAC,IAAI;IATxB,kDAAkD;IAClD,cAAc;IACd,gBAAgB,EAAE,MAAM,CAAC,UAAU,EAAE,eAAe,CAAC,CAAK;gBAOtC,IAAI,EAAE,IAAI,EAAE,QAAQ,GAAE,YAAY,EAAO;IAwD7D;;;OAGG;IACG,cAAc,CAAC,OAAO,EAAE,UAAU;IAyCxC;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC;IAatC,cAAc,CAAC,UAAU,EAAE,UAAU;IAIrC,2DAA2D;IAC3D,OAAO,CAAC,MAAM,EAAE,MAAM;IAgBtB,uDAAuD;IACvD,UAAU,CAAC,MAAM,EAAE,MAAM;IASzB,+CAA+C;IAC/C,IAAI,KAAK,IAAI,MAAM,EAAE,CAEpB;IAED,OAAO,IAAI;QACT,CAAC,GAAG,EAAE,MAAM,GAAG;YACb,KAAK,EAAE,MAAM,EAAE,CAAA;YACf,IAAI,EAAE;gBAAE,MAAM,EAAE,MAAM,CAAC;gBAAC,UAAU,EAAE,MAAM,CAAA;aAAE,CAAA;SAC7C,CAAA;KACF;CASF"}

package/dist/synchronizer/CollectionSynchronizer.js

@@ -1,5 +1,5 @@
 import debug from "debug";
-import { parseAutomergeUrl, stringifyAutomergeUrl } from "../AutomergeUrl.js";
+import { parseAutomergeUrl } from "../AutomergeUrl.js";
 import { DocSynchronizer } from "./DocSynchronizer.js";
 import { Synchronizer } from "./Synchronizer.js";
 const log = debug("automerge-repo:collectionsync");
@@ -20,17 +20,18 @@ export class CollectionSynchronizer extends Synchronizer {
         this.#denylist = denylist.map(url => parseAutomergeUrl(url).documentId);
     }
     /** Returns a synchronizer for the given document, creating one if it doesn't already exist.  */
-    #fetchDocSynchronizer(documentId) {
-        if (!this.docSynchronizers[documentId]) {
-            const handle = this.repo.find(stringifyAutomergeUrl({ documentId }));
-            this.docSynchronizers[documentId] = this.#initDocSynchronizer(handle);
+    #fetchDocSynchronizer(handle) {
+        if (!this.docSynchronizers[handle.documentId]) {
+            this.docSynchronizers[handle.documentId] =
+                this.#initDocSynchronizer(handle);
         }
-        return this.docSynchronizers[documentId];
+        return this.docSynchronizers[handle.documentId];
     }
     /** Creates a new docSynchronizer and sets it up to propagate messages */
     #initDocSynchronizer(handle) {
         const docSynchronizer = new DocSynchronizer({
             handle,
+            peerId: this.repo.networkSubsystem.peerId,
             onLoadSyncState: async (peerId) => {
                 if (!this.repo.storageSubsystem) {
                     return;
@@ -83,23 +84,26 @@ export class CollectionSynchronizer extends Synchronizer {
             return;
         }
         this.#docSetUp[documentId] = true;
-        const docSynchronizer = this.#fetchDocSynchronizer(documentId);
+        const handle = await this.repo.find(documentId, {
+            allowableStates: ["ready", "unavailable", "requesting"],
+        });
+        const docSynchronizer = this.#fetchDocSynchronizer(handle);
         docSynchronizer.receiveMessage(message);
         // Initiate sync with any new peers
         const peers = await this.#documentGenerousPeers(documentId);
-        docSynchronizer.beginSync(peers.filter(peerId => !docSynchronizer.hasPeer(peerId)));
+        void docSynchronizer.beginSync(peers.filter(peerId => !docSynchronizer.hasPeer(peerId)));
     }
     /**
      * Starts synchronizing the given document with all peers that we share it generously with.
      */
-    addDocument(documentId) {
+    addDocument(handle) {
         // HACK: this is a hack to prevent us from adding the same document twice
-        if (this.#docSetUp[documentId]) {
+        if (this.#docSetUp[handle.documentId]) {
             return;
         }
-        const docSynchronizer = this.#fetchDocSynchronizer(documentId);
-        void this.#documentGenerousPeers(documentId).then(peers => {
-            docSynchronizer.beginSync(peers);
+        const docSynchronizer = this.#fetchDocSynchronizer(handle);
+        void this.#documentGenerousPeers(handle.documentId).then(peers => {
+            void docSynchronizer.beginSync(peers);
         });
     }
     // TODO: implement this
@@ -118,7 +122,7 @@ export class CollectionSynchronizer extends Synchronizer {
             const { documentId } = docSynchronizer;
             void this.repo.sharePolicy(peerId, documentId).then(okToShare => {
                 if (okToShare)
-                    docSynchronizer.beginSync([peerId]);
+                    void docSynchronizer.beginSync([peerId]);
             });
         }
     }

package/dist/synchronizer/DocSynchronizer.d.ts

@@ -6,6 +6,7 @@ import { Synchronizer } from "./Synchronizer.js";
 type PeerDocumentStatus = "unknown" | "has" | "unavailable" | "wants";
 interface DocSynchronizerConfig {
     handle: DocHandle<unknown>;
+    peerId: PeerId;
     onLoadSyncState?: (peerId: PeerId) => Promise<A.SyncState | undefined>;
 }
 /**
@@ -15,11 +16,11 @@ interface DocSynchronizerConfig {
 export declare class DocSynchronizer extends Synchronizer {
     #private;
     syncDebounceRate: number;
-    constructor({ handle, onLoadSyncState }: DocSynchronizerConfig);
+    constructor({ handle, peerId, onLoadSyncState }: DocSynchronizerConfig);
     get peerStates(): Record<PeerId, PeerDocumentStatus>;
     get documentId(): import("../types.js").DocumentId;
     hasPeer(peerId: PeerId): boolean;
-    beginSync(peerIds: PeerId[]): void;
+    beginSync(peerIds: PeerId[]): Promise<void>;
     endSync(peerId: PeerId): void;
     receiveMessage(message: RepoMessage): void;
     receiveEphemeralMessage(message: EphemeralMessage): void;

package/dist/synchronizer/DocSynchronizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DocSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/DocSynchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gCAAgC,CAAA;AAGnD,OAAO,EACL,SAAS,EAKV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,gBAAgB,EAEhB,WAAW,EACX,cAAc,EACd,WAAW,EAEZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD,KAAK,kBAAkB,GAAG,SAAS,GAAG,KAAK,GAAG,aAAa,GAAG,OAAO,CAAA;AAOrE,UAAU,qBAAqB;IAC7B,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,CAAA;CACvE;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAE/C,gBAAgB,SAAM;gBAsBV,EAAE,MAAM,EAAE,eAAe,EAAE,EAAE,qBAAqB;IAyB9D,IAAI,UAAU,uCAEb;IAED,IAAI,UAAU,qCAEb;IAkID,OAAO,CAAC,MAAM,EAAE,MAAM;IAItB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE;IAmD3B,OAAO,CAAC,MAAM,EAAE,MAAM;IAKtB,cAAc,CAAC,OAAO,EAAE,WAAW;IAkBnC,uBAAuB,CAAC,OAAO,EAAE,gBAAgB;IAuBjD,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc;IAuFxD,OAAO,IAAI;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CAM7E"}
+{"version":3,"file":"DocSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/DocSynchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,gCAAgC,CAAA;AAGnD,OAAO,EACL,SAAS,EAKV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAEL,gBAAgB,EAEhB,WAAW,EACX,cAAc,EACd,WAAW,EAEZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD,KAAK,kBAAkB,GAAG,SAAS,GAAG,KAAK,GAAG,aAAa,GAAG,OAAO,CAAA;AAOrE,UAAU,qBAAqB;IAC7B,MAAM,EAAE,SAAS,CAAC,OAAO,CAAC,CAAA;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,SAAS,CAAC,CAAA;CACvE;AAED;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAE/C,gBAAgB,SAAM;gBAyBV,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,EAAE,qBAAqB;IAyBtE,IAAI,UAAU,uCAEb;IAED,IAAI,UAAU,qCAEb;IAqID,OAAO,CAAC,MAAM,EAAE,MAAM;IAIhB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE;IA8DjC,OAAO,CAAC,MAAM,EAAE,MAAM;IAKtB,cAAc,CAAC,OAAO,EAAE,WAAW;IAkBnC,uBAAuB,CAAC,OAAO,EAAE,gBAAgB;IAuBjD,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc;IAwFxD,OAAO,IAAI;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE;CAM7E"}