@automerge/automerge-repo 2.0.0-alpha.2 → 2.0.0-alpha.22

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));
 }
@@ -30,7 +31,8 @@ export class Repo extends EventEmitter {
     /** @hidden */
     saveDebounceRate = 100;
     #handleCache = {};
-    #synchronizer;
+    /** @hidden */
+    synchronizer;
     /** By default, we share generously with all peers. */
     /** @hidden */
     sharePolicy = async () => true;
@@ -39,31 +41,11 @@ export class Repo extends EventEmitter {
     peerMetadataByPeerId = {};
     #remoteHeadsSubscriptions = new RemoteHeadsSubscriptions();
     #remoteHeadsGossipingEnabled = false;
-    constructor({ storage, network = [], peerId = randomPeerId(), sharePolicy, isEphemeral = storage === undefined, enableRemoteHeadsGossiping = false, } = {}) {
+    constructor({ storage, network = [], peerId = randomPeerId(), sharePolicy, isEphemeral = storage === undefined, enableRemoteHeadsGossiping = false, denylist = [], } = {}) {
         super();
         this.#remoteHeadsGossipingEnabled = enableRemoteHeadsGossiping;
         this.#log = debug(`automerge-repo:repo`);
         this.sharePolicy = sharePolicy ?? this.sharePolicy;
-        // DOC COLLECTION
-        // The `document` event is fired by the DocCollection any time we create a new document or look
-        // up a document by ID. We listen for it in order to wire up storage and network synchronization.
-        this.on("document", async ({ handle }) => {
-            if (storageSubsystem) {
-                // Save when the document changes, but no more often than saveDebounceRate.
-                const saveFn = ({ handle, doc, }) => {
-                    void storageSubsystem.saveDoc(handle.documentId, doc);
-                };
-                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);
-        });
         this.on("delete-document", ({ documentId }) => {
             // TODO Pass the delete on to the network
             // synchronizer.removeDocument(documentId)
@@ -75,20 +57,25 @@ 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.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.synchronizer.on("open-doc", ({ peerId, documentId }) => {
                 this.#remoteHeadsSubscriptions.subscribePeerToDoc(peerId, documentId);
             });
         }
         // 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.
@@ -113,18 +100,18 @@ export class Repo extends EventEmitter {
                 .catch(err => {
                 console.log("error in share policy", { err });
             });
-            this.#synchronizer.addPeer(peerId);
+            this.synchronizer.addPeer(peerId);
         });
         // When a peer disconnects, remove it from the synchronizer
         networkSubsystem.on("peer-disconnected", ({ peerId }) => {
-            this.#synchronizer.removePeer(peerId);
+            this.synchronizer.removePeer(peerId);
             this.#remoteHeadsSubscriptions.removePeer(peerId);
         });
         // Handle incoming messages
         networkSubsystem.on("message", async (msg) => {
             this.#receiveMessage(msg);
         });
-        this.#synchronizer.on("sync-state", message => {
+        this.synchronizer.on("sync-state", message => {
             this.#saveSyncState(message);
             const handle = this.#handleCache[message.documentId];
             const { storageId } = this.peerMetadataByPeerId[message.peerId] || {};
@@ -133,11 +120,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));
                 }
             }
         });
@@ -172,6 +160,20 @@ export class Repo extends EventEmitter {
             });
         }
     }
+    // The `document` event is fired by the DocCollection any time we create a new document or look
+    // up a document by ID. We listen for it in order to wire up storage and network synchronization.
+    #registerHandleWithSubsystems(handle) {
+        const { storageSubsystem } = this;
+        if (storageSubsystem) {
+            // Save when the document changes, but no more often than saveDebounceRate.
+            const saveFn = ({ handle, doc }) => {
+                void storageSubsystem.saveDoc(handle.documentId, doc);
+            };
+            handle.on("heads-changed", throttle(saveFn, this.saveDebounceRate));
+        }
+        // Register the document with the synchronizer. This advertises our interest in the document.
+        this.synchronizer.addDocument(handle);
+    }
     #receiveMessage(message) {
         switch (message.type) {
             case "remote-subscription-change":
@@ -188,7 +190,7 @@ export class Repo extends EventEmitter {
             case "request":
             case "ephemeral":
             case "doc-unavailable":
-                this.#synchronizer.receiveMessage(message).catch(err => {
+                this.synchronizer.receiveMessage(message).catch(err => {
                     console.log("error receiving message", { err });
                 });
         }
@@ -229,7 +231,7 @@ export class Repo extends EventEmitter {
     }
     /** Returns a list of all connected peer ids */
     get peers() {
-        return this.#synchronizer.peers;
+        return this.synchronizer.peers;
     }
     getStorageIdOfPeer(peerId) {
         return this.peerMetadataByPeerId[peerId]?.storageId;
@@ -245,7 +247,7 @@ export class Repo extends EventEmitter {
         const handle = this.#getHandle({
             documentId,
         });
-        this.emit("document", { handle });
+        this.#registerHandleWithSubsystems(handle);
         handle.update(() => {
             let nextDoc;
             if (initialValue) {
@@ -271,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.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
@@ -290,57 +287,172 @@ 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 abortPromise = abortable(signal);
+        const { documentId, heads } = isValidAutomergeUrl(id)
+            ? parseAutomergeUrl(id)
+            : { documentId: interpretAsDocumentId(id), heads: undefined };
+        // Check 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) {
+                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,
+                };
             }
-            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,
-        });
-        // Try to load from disk before telling anyone else about it
-        if (this.storageSubsystem) {
-            void this.storageSubsystem.loadDoc(handle.documentId).then(loadedDoc => {
+        // 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) {
-                    // uhhhh, sorry if you're reading this because we were lying to the type system
                     handle.update(() => loadedDoc);
                     handle.doneLoading();
+                    yield { state: "loading", progress: 50, handle };
                 }
                 else {
-                    this.networkSubsystem
-                        .whenReady()
-                        .then(() => {
-                        handle.request();
-                    })
-                        .catch(err => {
-                        this.#log("error waiting for network", { err });
-                    });
-                    this.emit("document", { handle });
+                    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 };
+            }
+            catch (error) {
+                yield {
+                    state: "failed",
+                    error: error instanceof Error ? error : new Error(String(error)),
+                    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.emit("document", { handle });
         }
+        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 */
     id) {
@@ -360,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);
     }
     /**
@@ -408,17 +518,46 @@ 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();
         });
         return this.flush();
     }
+    metrics() {
+        return { documents: this.synchronizer.metrics() };
+    }
 }

package/dist/entrypoints/fullfat.d.ts

@@ -1,2 +1,3 @@
 export * from "../index.js";
+import "@automerge/automerge";
 //# sourceMappingURL=fullfat.d.ts.map

package/dist/entrypoints/fullfat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fullfat.d.ts","sourceRoot":"","sources":["../../src/entrypoints/fullfat.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA"}
+{"version":3,"file":"fullfat.d.ts","sourceRoot":"","sources":["../../src/entrypoints/fullfat.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAS3B,OAAO,sBAAsB,CAAA"}

package/dist/entrypoints/fullfat.js

@@ -6,5 +6,4 @@ export * from "../index.js";
 // disable
 //
 // eslint-disable-next-line automerge-slimport/enforce-automerge-slim-import
-import { next as Am } from "@automerge/automerge";
-Am.init();
+import "@automerge/automerge";

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/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,cAAe,MAAM,KAAG,UAS3D,CAAA;AAED,eAAO,MAAM,qBAAqB,SAAU,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/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,MAAO,QAAQ,KAAK,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/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"}