@automerge/automerge-repo 2.0.0-alpha.7 → 2.0.0-beta.2

package/dist/Repo.js

@@ -1,14 +1,15 @@
 import { next as Automerge } from "@automerge/automerge/slim";
 import debug from "debug";
 import { EventEmitter } from "eventemitter3";
-import { generateAutomergeUrl, interpretAsDocumentId, parseAutomergeUrl, } from "./AutomergeUrl.js";
-import { DocHandle } from "./DocHandle.js";
+import { encodeHeads, generateAutomergeUrl, interpretAsDocumentId, isValidAutomergeUrl, parseAutomergeUrl, } from "./AutomergeUrl.js";
+import { DELETED, DocHandle, READY, UNAVAILABLE, UNLOADED, } from "./DocHandle.js";
 import { RemoteHeadsSubscriptions } from "./RemoteHeadsSubscriptions.js";
 import { headsAreSame } from "./helpers/headsAreSame.js";
 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));
 }
@@ -40,7 +41,8 @@ export class Repo extends EventEmitter {
     peerMetadataByPeerId = {};
     #remoteHeadsSubscriptions = new RemoteHeadsSubscriptions();
     #remoteHeadsGossipingEnabled = false;
-    constructor({ storage, network = [], peerId = randomPeerId(), sharePolicy, isEphemeral = storage === undefined, enableRemoteHeadsGossiping = false, } = {}) {
+    #progressCache = {};
+    constructor({ storage, network = [], peerId = randomPeerId(), sharePolicy, isEphemeral = storage === undefined, enableRemoteHeadsGossiping = false, denylist = [], } = {}) {
         super();
         this.#remoteHeadsGossipingEnabled = enableRemoteHeadsGossiping;
         this.#log = debug(`automerge-repo:repo`);
@@ -56,12 +58,14 @@ export class Repo extends EventEmitter {
         });
         // SYNCHRONIZER
         // The synchronizer uses the network subsystem to keep documents in sync with peers.
-        this.synchronizer = new CollectionSynchronizer(this);
+        this.synchronizer = new CollectionSynchronizer(this, denylist);
         // When the synchronizer emits messages, send them to peers
         this.synchronizer.on("message", message => {
             this.#log(`sending ${message.type} message to ${message.targetId}`);
             networkSubsystem.send(message);
         });
+        // Forward metrics from doc synchronizers
+        this.synchronizer.on("metrics", event => this.emit("doc-metrics", event));
         if (this.#remoteHeadsGossipingEnabled) {
             this.synchronizer.on("open-doc", ({ peerId, documentId }) => {
                 this.#remoteHeadsSubscriptions.subscribePeerToDoc(peerId, documentId);
@@ -70,6 +74,9 @@ export class Repo extends EventEmitter {
         // STORAGE
         // The storage subsystem has access to some form of persistence, and deals with save and loading documents.
         const storageSubsystem = storage ? new StorageSubsystem(storage) : undefined;
+        if (storageSubsystem) {
+            storageSubsystem.on("document-loaded", event => this.emit("doc-metrics", { type: "doc-loaded", ...event }));
+        }
         this.storageSubsystem = storageSubsystem;
         // NETWORK
         // The network subsystem deals with sending and receiving messages to and from peers.
@@ -114,11 +121,12 @@ export class Repo extends EventEmitter {
             }
             const heads = handle.getRemoteHeads(storageId);
             const haveHeadsChanged = message.syncState.theirHeads &&
-                (!heads || !headsAreSame(heads, message.syncState.theirHeads));
+                (!heads ||
+                    !headsAreSame(heads, encodeHeads(message.syncState.theirHeads)));
             if (haveHeadsChanged && message.syncState.theirHeads) {
-                handle.setRemoteHeads(storageId, message.syncState.theirHeads);
+                handle.setRemoteHeads(storageId, encodeHeads(message.syncState.theirHeads));
                 if (storageId && this.#remoteHeadsGossipingEnabled) {
-                    this.#remoteHeadsSubscriptions.handleImmediateRemoteHeadsChanged(message.documentId, storageId, message.syncState.theirHeads);
+                    this.#remoteHeadsSubscriptions.handleImmediateRemoteHeadsChanged(message.documentId, storageId, encodeHeads(message.syncState.theirHeads));
                 }
             }
         });
@@ -164,16 +172,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) {
@@ -274,18 +274,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.waitForReady() first.)`);
-        }
-        const sourceDoc = clonedHandle.docSync();
-        if (!sourceDoc) {
-            throw new Error("Cloned handle doesn't have a document.");
+        (Try await handle.whenReady() first.)`);
         }
+        const sourceDoc = clonedHandle.doc();
         const handle = this.create();
         handle.update(() => {
             // we replace the document with the new cloned one
@@ -293,55 +288,220 @@ 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) {
-        const documentId = interpretAsDocumentId(id);
-        // If we have the handle cached, return it
+    findWithProgress(id, options = {}) {
+        const { signal } = options;
+        const { documentId, heads } = isValidAutomergeUrl(id)
+            ? parseAutomergeUrl(id)
+            : { documentId: interpretAsDocumentId(id), heads: undefined };
+        // Check handle cache first - return plain FindStep for terminal states
         if (this.#handleCache[documentId]) {
-            if (this.#handleCache[documentId].isUnavailable()) {
-                // this ensures that the event fires after the handle has been returned
-                setTimeout(() => {
-                    this.#handleCache[documentId].emit("unavailable", {
-                        handle: 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) {
+                const result = {
+                    state: "failed",
+                    error: new Error(`Document ${id} was deleted`),
+                    handle,
+                };
+                return result;
+            }
+            if (handle.state === READY) {
+                const result = {
+                    state: "ready",
+                    handle: heads ? handle.view(heads) : handle,
+                };
+                return result;
             }
-            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,
-        });
-        // 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) => {
+        // Check progress cache for any existing signal
+        const cachedProgress = this.#progressCache[documentId];
+        if (cachedProgress) {
+            const handle = this.#handleCache[documentId];
+            // Return cached progress if we have a handle and it's either in a terminal state or loading
+            if (handle &&
+                (handle.state === READY ||
+                    handle.state === UNAVAILABLE ||
+                    handle.state === DELETED ||
+                    handle.state === "loading")) {
+                return cachedProgress;
+            }
+        }
+        const handle = this.#getHandle({ documentId });
+        const initial = {
+            state: "loading",
+            progress: 0,
+            handle,
+        };
+        // Create a new progress signal
+        const progressSignal = {
+            subscribers: new Set(),
+            currentProgress: undefined,
+            notify: (progress) => {
+                progressSignal.currentProgress = progress;
+                progressSignal.subscribers.forEach(callback => callback(progress));
+                // Cache all states, not just terminal ones
+                this.#progressCache[documentId] = progress;
+            },
+            peek: () => progressSignal.currentProgress || initial,
+            subscribe: (callback) => {
+                progressSignal.subscribers.add(callback);
+                return () => progressSignal.subscribers.delete(callback);
+            },
+        };
+        progressSignal.notify(initial);
+        // Start the loading process
+        void this.#loadDocumentWithProgress(id, documentId, handle, progressSignal, signal ? abortable(new Promise(() => { }), signal) : new Promise(() => { }));
+        const result = {
+            ...initial,
+            peek: progressSignal.peek,
+            subscribe: progressSignal.subscribe,
+        };
+        this.#progressCache[documentId] = result;
+        return result;
+    }
+    async #loadDocumentWithProgress(id, documentId, handle, progressSignal, abortPromise) {
+        try {
+            progressSignal.notify({
+                state: "loading",
+                progress: 25,
+                handle,
+            });
+            const loadingPromise = await (this.storageSubsystem
+                ? this.storageSubsystem.loadDoc(handle.documentId)
+                : Promise.resolve(null));
+            const loadedDoc = await Promise.race([loadingPromise, abortPromise]);
             if (loadedDoc) {
-                // uhhhh, sorry if you're reading this because we were lying to the type system
                 handle.update(() => loadedDoc);
                 handle.doneLoading();
+                progressSignal.notify({
+                    state: "loading",
+                    progress: 50,
+                    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();
+                await Promise.race([this.networkSubsystem.whenReady(), abortPromise]);
                 handle.request();
+                progressSignal.notify({
+                    state: "loading",
+                    progress: 75,
+                    handle,
+                });
             }
             this.#registerHandleWithSubsystems(handle);
-        })
-            .catch(err => {
-            this.#log("error waiting for network", { err });
-        });
+            await Promise.race([handle.whenReady([READY, UNAVAILABLE]), abortPromise]);
+            if (handle.state === UNAVAILABLE) {
+                const unavailableProgress = {
+                    state: "unavailable",
+                    handle,
+                };
+                progressSignal.notify(unavailableProgress);
+                return;
+            }
+            if (handle.state === DELETED) {
+                throw new Error(`Document ${id} was deleted`);
+            }
+            progressSignal.notify({ state: "ready", handle });
+        }
+        catch (error) {
+            progressSignal.notify({
+                state: "failed",
+                error: error instanceof Error ? error : new Error(String(error)),
+                handle: this.#getHandle({ documentId }),
+            });
+        }
+    }
+    async find(id, options = {}) {
+        const { allowableStates = ["ready"], signal } = options;
+        // Check if already aborted
+        if (signal?.aborted) {
+            throw new Error("Operation aborted");
+        }
+        const progress = this.findWithProgress(id, { signal });
+        if ("subscribe" in progress) {
+            this.#registerHandleWithSubsystems(progress.handle);
+            return new Promise((resolve, reject) => {
+                const unsubscribe = progress.subscribe(state => {
+                    if (allowableStates.includes(state.handle.state)) {
+                        unsubscribe();
+                        resolve(state.handle);
+                    }
+                    else if (state.state === "unavailable") {
+                        unsubscribe();
+                        reject(new Error(`Document ${id} is unavailable`));
+                    }
+                    else if (state.state === "failed") {
+                        unsubscribe();
+                        reject(state.error);
+                    }
+                });
+            });
+        }
+        else {
+            if (progress.handle.state === READY) {
+                return progress.handle;
+            }
+            // If the handle isn't ready, wait for it and then return it
+            await progress.handle.whenReady([READY, UNAVAILABLE]);
+            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 abortable((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;
+        })(), signal);
+    }
     delete(
     /** The url or documentId of the handle to delete */
     id) {
@@ -349,6 +509,7 @@ export class Repo extends EventEmitter {
         const handle = this.#getHandle({ documentId });
         handle.delete();
         delete this.#handleCache[documentId];
+        delete this.#progressCache[documentId];
         this.emit("delete-document", { documentId });
     }
     /**
@@ -361,9 +522,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);
     }
     /**
@@ -409,13 +568,39 @@ 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());
         }));
     }
+    /**
+     * Removes a DocHandle from the handleCache.
+     * @hidden this API is experimental and may change.
+     * @param documentId - documentId of the DocHandle to remove from handleCache, if present in cache.
+     * @returns Promise<void>
+     */
+    async removeFromCache(documentId) {
+        if (!this.#handleCache[documentId]) {
+            this.#log(`WARN: removeFromCache called but handle not found in handleCache for documentId: ${documentId}`);
+            return;
+        }
+        const handle = this.#getHandle({ documentId });
+        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();
+            }
+            else {
+                this.#log(`WARN: removeFromCache called but handle for documentId: ${documentId} in unexpected state: ${handle.state}`);
+            }
+            delete this.#handleCache[documentId];
+            // TODO: remove document from synchronizer when removeDocument is implemented
+            // this.synchronizer.removeDocument(documentId)
+        }
+        else {
+            this.#log(`WARN: removeFromCache called but doc undefined for documentId: ${documentId}`);
+        }
+    }
     shutdown() {
         this.networkSubsystem.adapters.forEach(adapter => {
             adapter.disconnect();

package/dist/helpers/abortable.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Wraps a Promise and causes it to reject when the signal is aborted.
+ *
+ * @remarks
+ * This utility wraps a Promise and rejects when the provided AbortSignal is aborted.
+ * It's designed to make Promise awaits abortable.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ *
+ * try {
+ *   const result = await abortable(fetch('https://api.example.com/data'), controller.signal);
+ *   // Meanwhile, to abort in concurrent code before the above line returns: controller.abort();
+ * } catch (err) {
+ *   if (err.name === 'AbortError') {
+ *     console.log('The operation was aborted');
+ *   }
+ * }
+ *
+ * ```
+ *
+ * @param p - A Promise to wrap
+ * @param signal - An AbortSignal that can be used to abort the operation
+ * @returns A wrapper Promise that rejects with AbortError if the signal is aborted
+ * before the promise p settles, and settles as p settles otherwise
+ * @throws {DOMException} With name "AbortError" if aborted before p settles
+ */
+export declare function abortable<T>(p: Promise<T>, signal: AbortSignal | undefined): Promise<T>;
+/**
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,wBAAgB,SAAS,CAAC,CAAC,EACzB,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EACb,MAAM,EAAE,WAAW,GAAG,SAAS,GAC9B,OAAO,CAAC,CAAC,CAAC,CAsBZ;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,WAAW,CAAA;CACrB"}

package/dist/helpers/abortable.js

@@ -0,0 +1,47 @@
+/**
+ * Wraps a Promise and causes it to reject when the signal is aborted.
+ *
+ * @remarks
+ * This utility wraps a Promise and rejects when the provided AbortSignal is aborted.
+ * It's designed to make Promise awaits abortable.
+ *
+ * @example
+ * ```typescript
+ * const controller = new AbortController();
+ *
+ * try {
+ *   const result = await abortable(fetch('https://api.example.com/data'), controller.signal);
+ *   // Meanwhile, to abort in concurrent code before the above line returns: controller.abort();
+ * } catch (err) {
+ *   if (err.name === 'AbortError') {
+ *     console.log('The operation was aborted');
+ *   }
+ * }
+ *
+ * ```
+ *
+ * @param p - A Promise to wrap
+ * @param signal - An AbortSignal that can be used to abort the operation
+ * @returns A wrapper Promise that rejects with AbortError if the signal is aborted
+ * before the promise p settles, and settles as p settles otherwise
+ * @throws {DOMException} With name "AbortError" if aborted before p settles
+ */
+export function abortable(p, signal) {
+    let settled = false;
+    return new Promise((resolve, reject) => {
+        signal?.addEventListener("abort", () => {
+            if (!settled) {
+                reject(new DOMException("Operation aborted", "AbortError"));
+            }
+        }, { once: true });
+        p.then(result => {
+            resolve(result);
+        })
+            .catch(error => {
+            reject(error);
+        })
+            .finally(() => {
+            settled = true;
+        });
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"arraysAreEqual.d.ts","sourceRoot":"","sources":["../../src/helpers/arraysAreEqual.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,EAAE,YAC4B,CAAA"}
+{"version":3,"file":"arraysAreEqual.d.ts","sourceRoot":"","sources":["../../src/helpers/arraysAreEqual.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,YAC4B,CAAA"}

package/dist/helpers/bufferFromHex.d.ts

@@ -0,0 +1,3 @@
+export declare const uint8ArrayFromHexString: (hexString: string) => Uint8Array;
+export declare const uint8ArrayToHexString: (data: Uint8Array) => string;
+//# sourceMappingURL=bufferFromHex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bufferFromHex.d.ts","sourceRoot":"","sources":["../../src/helpers/bufferFromHex.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,GAAI,WAAW,MAAM,KAAG,UAS3D,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,MAAM,UAAU,KAAG,MAExD,CAAA"}

package/dist/helpers/bufferFromHex.js

@@ -0,0 +1,13 @@
+export const uint8ArrayFromHexString = (hexString) => {
+    if (hexString.length % 2 !== 0) {
+        throw new Error("Hex string must have an even length");
+    }
+    const bytes = new Uint8Array(hexString.length / 2);
+    for (let i = 0; i < hexString.length; i += 2) {
+        bytes[i >> 1] = parseInt(hexString.slice(i, i + 2), 16);
+    }
+    return bytes;
+};
+export const uint8ArrayToHexString = (data) => {
+    return Array.from(data, byte => byte.toString(16).padStart(2, "0")).join("");
+};

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

@@ -1 +1 @@
-{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../src/helpers/debounce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,MACtE,CAAC,QACC,MAAM,eAGc,UAAU,CAAC,CAAC,CAAC,SAMxC,CAAA"}
+{"version":3,"file":"debounce.d.ts","sourceRoot":"","sources":["../../src/helpers/debounce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,EAC1E,IAAI,CAAC,EACL,MAAM,MAAM,MAGK,GAAG,MAAM,UAAU,CAAC,CAAC,CAAC,SAMxC,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"eventPromise.d.ts","sourceRoot":"","sources":["../../src/helpers/eventPromise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAE5C,4FAA4F;AAC5F,eAAO,MAAM,YAAY,YAAa,YAAY,SAAS,MAAM,iBACE,CAAA;AAEnE,eAAO,MAAM,aAAa,aAAc,YAAY,EAAE,SAAS,MAAM,mBAGpE,CAAA"}
+{"version":3,"file":"eventPromise.d.ts","sourceRoot":"","sources":["../../src/helpers/eventPromise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAE5C,4FAA4F;AAC5F,eAAO,MAAM,YAAY,GAAI,SAAS,YAAY,EAAE,OAAO,MAAM,iBACE,CAAA;AAEnE,eAAO,MAAM,aAAa,GAAI,UAAU,YAAY,EAAE,EAAE,OAAO,MAAM,mBAGpE,CAAA"}

package/dist/helpers/headsAreSame.d.ts

@@ -1,3 +1,3 @@
-import { Heads } from "@automerge/automerge/slim/next";
-export declare const headsAreSame: (a: Heads, b: Heads) => boolean;
+import type { UrlHeads } from "../types.js";
+export declare const headsAreSame: (a: UrlHeads, b: UrlHeads) => boolean;
 //# sourceMappingURL=headsAreSame.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"headsAreSame.d.ts","sourceRoot":"","sources":["../../src/helpers/headsAreSame.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAA;AAGtD,eAAO,MAAM,YAAY,MAAO,KAAK,KAAK,KAAK,YAE9C,CAAA"}
+{"version":3,"file":"headsAreSame.d.ts","sourceRoot":"","sources":["../../src/helpers/headsAreSame.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAE3C,eAAO,MAAM,YAAY,GAAI,GAAG,QAAQ,EAAE,GAAG,QAAQ,YAEpD,CAAA"}

package/dist/helpers/mergeArrays.d.ts

@@ -1,2 +1,2 @@
-export declare function mergeArrays(myArrays: Uint8Array[]): Uint8Array;
+export declare function mergeArrays(myArrays: Uint8Array[]): Uint8Array<ArrayBuffer>;
 //# sourceMappingURL=mergeArrays.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mergeArrays.d.ts","sourceRoot":"","sources":["../../src/helpers/mergeArrays.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,cAgBjD"}
+{"version":3,"file":"mergeArrays.d.ts","sourceRoot":"","sources":["../../src/helpers/mergeArrays.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,QAAQ,EAAE,UAAU,EAAE,2BAgBjD"}

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

@@ -1 +1 @@
-{"version":3,"file":"pause.d.ts","sourceRoot":"","sources":["../../src/helpers/pause.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK,+BAC4C,CAAA"}
+{"version":3,"file":"pause.d.ts","sourceRoot":"","sources":["../../src/helpers/pause.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK,GAAI,UAAK,kBACmC,CAAA"}

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"}