@automerge/automerge-repo 2.0.0-alpha.7 → 2.0.0-collectionsync-alpha.1

package/dist/Repo.js

@@ -2,13 +2,12 @@ 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 { RemoteHeadsSubscriptions } from "./RemoteHeadsSubscriptions.js";
-import { headsAreSame } from "./helpers/headsAreSame.js";
-import { throttle } from "./helpers/throttle.js";
+import { DELETED, DocHandle, READY, UNAVAILABLE, UNLOADED, } from "./DocHandle.js";
 import { NetworkSubsystem } from "./network/NetworkSubsystem.js";
 import { StorageSubsystem } from "./storage/StorageSubsystem.js";
 import { CollectionSynchronizer } from "./synchronizer/CollectionSynchronizer.js";
+import { next as A } from "@automerge/automerge/slim";
+import { InMemoryStorageAdapter } from "./storage/StorageAdapter.js";
 function randomPeerId() {
     return ("peer-" + Math.random().toString(36).slice(4));
 }
@@ -24,11 +23,7 @@ export class Repo extends EventEmitter {
     #log;
     /** @hidden */
     networkSubsystem;
-    /** @hidden */
     storageSubsystem;
-    /** The debounce rate is adjustable on the repo. */
-    /** @hidden */
-    saveDebounceRate = 100;
     #handleCache = {};
     /** @hidden */
     synchronizer;
@@ -38,43 +33,73 @@ export class Repo extends EventEmitter {
     /** maps peer id to to persistence information (storageId, isEphemeral), access by collection synchronizer  */
     /** @hidden */
     peerMetadataByPeerId = {};
-    #remoteHeadsSubscriptions = new RemoteHeadsSubscriptions();
-    #remoteHeadsGossipingEnabled = false;
-    constructor({ storage, network = [], peerId = randomPeerId(), sharePolicy, isEphemeral = storage === undefined, enableRemoteHeadsGossiping = false, } = {}) {
+    #beelay;
+    constructor({ storage, network = [], peerId = randomPeerId(), sharePolicy, isEphemeral = storage === undefined, enableRemoteHeadsGossiping = false, denylist = [], } = {}) {
         super();
-        this.#remoteHeadsGossipingEnabled = enableRemoteHeadsGossiping;
+        if (storage == null) {
+            // beelayStorage = new InMemoryStorageAdapter()
+            storage = new InMemoryStorageAdapter();
+        }
+        this.#beelay = new A.beelay.Beelay({
+            storage,
+            peerId,
+            requestPolicy: async ({ docId }) => {
+                const peers = Array.from(this.networkSubsystem.peers);
+                const generousPeers = [];
+                for (const peerId of peers) {
+                    const okToShare = await this.sharePolicy(peerId);
+                    if (okToShare)
+                        generousPeers.push(peerId);
+                }
+                return generousPeers;
+            },
+        });
+        this.storageSubsystem = new StorageSubsystem(this.#beelay, storage);
         this.#log = debug(`automerge-repo:repo`);
         this.sharePolicy = sharePolicy ?? this.sharePolicy;
-        this.on("delete-document", ({ documentId }) => {
-            // TODO Pass the delete on to the network
-            // synchronizer.removeDocument(documentId)
-            if (storageSubsystem) {
-                storageSubsystem.removeDoc(documentId).catch(err => {
-                    this.#log("error deleting document", { documentId, err });
-                });
+        this.#beelay.on("message", ({ message }) => {
+            this.#log(`sending ${message} message to ${message.recipient}`);
+            networkSubsystem.send({
+                targetId: message.recipient,
+                type: "beelay",
+                ...message,
+            });
+        });
+        this.#beelay.on("docEvent", event => {
+            this.#log(`received ${event.data.type} event for ${event.docId}`);
+            const handle = this.#handleCache[event.docId];
+            if (handle != null) {
+                handle.update(d => Automerge.loadIncremental(d, event.data.contents));
             }
         });
+        this.#beelay.on("bundleRequired", ({ start, end, checkpoints, docId }) => {
+            ;
+            (async () => {
+                const doc = await this.storageSubsystem.loadDoc(docId);
+                if (doc == null) {
+                    console.warn("document not found when creating bundle");
+                    return;
+                }
+                const bundle = A.saveBundle(doc, start, end);
+                this.#beelay.addBundle({
+                    docId,
+                    checkpoints,
+                    start,
+                    end,
+                    data: bundle,
+                });
+            })();
+        });
         // SYNCHRONIZER
-        // The synchronizer uses the network subsystem to keep documents in sync with peers.
-        this.synchronizer = new CollectionSynchronizer(this);
-        // When the synchronizer emits messages, send them to peers
+        this.synchronizer = new CollectionSynchronizer(this.#beelay, this, []);
         this.synchronizer.on("message", message => {
             this.#log(`sending ${message.type} message to ${message.targetId}`);
             networkSubsystem.send(message);
         });
-        if (this.#remoteHeadsGossipingEnabled) {
-            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;
-        this.storageSubsystem = storageSubsystem;
         // NETWORK
         // The network subsystem deals with sending and receiving messages to and from peers.
         const myPeerMetadata = (async () => ({
-            storageId: await storageSubsystem?.id(),
+            // storageId: await this.storageSubsystem.id(),
             isEphemeral,
         }))();
         const networkSubsystem = new NetworkSubsystem(network, peerId, myPeerMetadata);
@@ -85,92 +110,50 @@ export class Repo extends EventEmitter {
             if (peerMetadata) {
                 this.peerMetadataByPeerId[peerId] = { ...peerMetadata };
             }
-            this.sharePolicy(peerId)
-                .then(shouldShare => {
-                if (shouldShare && this.#remoteHeadsGossipingEnabled) {
-                    this.#remoteHeadsSubscriptions.addGenerousPeer(peerId);
-                }
-            })
-                .catch(err => {
-                console.log("error in share policy", { err });
-            });
             this.synchronizer.addPeer(peerId);
         });
-        // When a peer disconnects, remove it from the synchronizer
-        networkSubsystem.on("peer-disconnected", ({ 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.#saveSyncState(message);
-            const handle = this.#handleCache[message.documentId];
-            const { storageId } = this.peerMetadataByPeerId[message.peerId] || {};
-            if (!storageId) {
-                return;
-            }
-            const heads = handle.getRemoteHeads(storageId);
-            const haveHeadsChanged = message.syncState.theirHeads &&
-                (!heads || !headsAreSame(heads, message.syncState.theirHeads));
-            if (haveHeadsChanged && message.syncState.theirHeads) {
-                handle.setRemoteHeads(storageId, message.syncState.theirHeads);
-                if (storageId && this.#remoteHeadsGossipingEnabled) {
-                    this.#remoteHeadsSubscriptions.handleImmediateRemoteHeadsChanged(message.documentId, storageId, message.syncState.theirHeads);
+            //@ts-ignore
+            // const inspected = A.beelay.inspectMessage(msg.message)
+            // this.#log(`received msg: ${JSON.stringify(inspected)}`)
+            //@ts-ignore
+            if (msg.type === "beelay") {
+                if (!(msg.message instanceof Uint8Array)) {
+                    // The Uint8Array instance in the vitest VM is _different_ from the
+                    // Uint8Array instance which is available in this file for some reason.
+                    // So, even though `msg.message` _is_ a `Uint8Array`, we have to do this
+                    // absurd thing to get the tests to pass
+                    msg.message = Uint8Array.from(msg.message);
                 }
-            }
-        });
-        if (this.#remoteHeadsGossipingEnabled) {
-            this.#remoteHeadsSubscriptions.on("notify-remote-heads", message => {
-                this.networkSubsystem.send({
-                    type: "remote-heads-changed",
-                    targetId: message.targetId,
-                    documentId: message.documentId,
-                    newHeads: {
-                        [message.storageId]: {
-                            heads: message.heads,
-                            timestamp: message.timestamp,
-                        },
+                this.#beelay.receiveMessage({
+                    message: {
+                        sender: msg.senderId,
+                        recipient: msg.targetId,
+                        message: msg.message,
                     },
                 });
-            });
-            this.#remoteHeadsSubscriptions.on("change-remote-subs", message => {
-                this.#log("change-remote-subs", message);
-                for (const peer of message.peers) {
-                    this.networkSubsystem.send({
-                        type: "remote-subscription-change",
-                        targetId: peer,
-                        add: message.add,
-                        remove: message.remove,
-                    });
-                }
-            });
-            this.#remoteHeadsSubscriptions.on("remote-heads-changed", message => {
-                const handle = this.#handleCache[message.documentId];
-                handle.setRemoteHeads(message.storageId, message.remoteHeads);
-            });
-        }
+            }
+            else {
+                this.#receiveMessage(msg);
+            }
+        });
     }
     // 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));
-        }
+        handle.on("heads-changed", () => {
+            const doc = handle.docSync();
+            if (doc != null) {
+                this.storageSubsystem.saveDoc(handle.documentId, doc);
+            }
+        });
         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 });
@@ -178,42 +161,18 @@ export class Repo extends EventEmitter {
     #receiveMessage(message) {
         switch (message.type) {
             case "remote-subscription-change":
-                if (this.#remoteHeadsGossipingEnabled) {
-                    this.#remoteHeadsSubscriptions.handleControlMessage(message);
-                }
-                break;
             case "remote-heads-changed":
-                if (this.#remoteHeadsGossipingEnabled) {
-                    this.#remoteHeadsSubscriptions.handleRemoteHeads(message);
-                }
                 break;
             case "sync":
             case "request":
             case "ephemeral":
             case "doc-unavailable":
                 this.synchronizer.receiveMessage(message).catch(err => {
-                    console.log("error receiving message", { err });
+                    console.error("error receiving message", { err });
                 });
+                break;
         }
     }
-    #throttledSaveSyncStateHandlers = {};
-    /** saves sync state throttled per storage id, if a peer doesn't have a storage id it's sync state is not persisted */
-    #saveSyncState(payload) {
-        if (!this.storageSubsystem) {
-            return;
-        }
-        const { storageId, isEphemeral } = this.peerMetadataByPeerId[payload.peerId] || {};
-        if (!storageId || isEphemeral) {
-            return;
-        }
-        let handler = this.#throttledSaveSyncStateHandlers[storageId];
-        if (!handler) {
-            handler = this.#throttledSaveSyncStateHandlers[storageId] = throttle(({ documentId, syncState }) => {
-                void this.storageSubsystem.saveSyncState(documentId, storageId, syncState);
-            }, this.saveDebounceRate);
-        }
-        handler(payload);
-    }
     /** Returns an existing handle if we have it; creates one otherwise. */
     #getHandle({ documentId, }) {
         // If we have the handle cached, return it
@@ -232,7 +191,7 @@ export class Repo extends EventEmitter {
     }
     /** Returns a list of all connected peer ids */
     get peers() {
-        return this.synchronizer.peers;
+        return this.networkSubsystem.peers;
     }
     getStorageIdOfPeer(peerId) {
         return this.peerMetadataByPeerId[peerId]?.storageId;
@@ -248,7 +207,7 @@ export class Repo extends EventEmitter {
         const handle = this.#getHandle({
             documentId,
         });
-        this.#registerHandleWithSubsystems(handle);
+        let initialLinks = [];
         handle.update(() => {
             let nextDoc;
             if (initialValue) {
@@ -257,8 +216,27 @@ export class Repo extends EventEmitter {
             else {
                 nextDoc = Automerge.emptyChange(Automerge.init());
             }
+            const patches = A.diff(nextDoc, [], A.getHeads(nextDoc));
+            for (const patch of patches) {
+                initialLinks = patches
+                    .map(patch => {
+                    if (patch.action === "put") {
+                        if (patch.value instanceof A.Link) {
+                            return patch.value;
+                        }
+                    }
+                    return null;
+                })
+                    .filter(v => v != null);
+            }
             return nextDoc;
         });
+        for (const link of initialLinks) {
+            const { documentId: target } = parseAutomergeUrl(link.target);
+            this.#beelay.addLink({ from: documentId, to: target });
+        }
+        this.storageSubsystem.saveDoc(handle.documentId, handle.docSync());
+        this.#registerHandleWithSubsystems(handle);
         handle.doneLoading();
         return handle;
     }
@@ -280,7 +258,7 @@ export class Repo extends EventEmitter {
     clone(clonedHandle) {
         if (!clonedHandle.isReady()) {
             throw new Error(`Cloned handle is not yet in ready state.
-        (Try await handle.waitForReady() first.)`);
+        (Try await handle.whenReady() first.)`);
         }
         const sourceDoc = clonedHandle.docSync();
         if (!sourceDoc) {
@@ -300,6 +278,7 @@ export class Repo extends EventEmitter {
     find(
     /** The url or documentId of the handle to retrieve */
     id) {
+        this.#log("find", { id });
         const documentId = interpretAsDocumentId(id);
         // If we have the handle cached, return it
         if (this.#handleCache[documentId]) {
@@ -319,9 +298,7 @@ export class Repo extends EventEmitter {
         });
         // 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);
+        const attemptLoad = this.storageSubsystem.loadDoc(handle.documentId);
         attemptLoad
             .then(async (loadedDoc) => {
             if (loadedDoc) {
@@ -333,6 +310,7 @@ export class Repo extends EventEmitter {
                 // 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();
+                console.log("we didn't find it so we're requesting");
                 handle.request();
             }
             this.#registerHandleWithSubsystems(handle);
@@ -378,15 +356,7 @@ export class Repo extends EventEmitter {
         });
         return handle;
     }
-    subscribeToRemotes = (remotes) => {
-        if (this.#remoteHeadsGossipingEnabled) {
-            this.#log("subscribeToRemotes", { remotes });
-            this.#remoteHeadsSubscriptions.subscribeToRemotes(remotes);
-        }
-        else {
-            this.#log("WARN: subscribeToRemotes called but remote heads gossiping is not enabled");
-        }
-    };
+    subscribeToRemotes = (remotes) => { };
     storageId = async () => {
         if (!this.storageSubsystem) {
             return undefined;
@@ -416,6 +386,34 @@ export class Repo extends EventEmitter {
             return this.storageSubsystem.saveDoc(handle.documentId, 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 });
+        const doc = await handle.doc([READY, UNLOADED, DELETED, UNAVAILABLE]);
+        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();
@@ -423,6 +421,7 @@ export class Repo extends EventEmitter {
         return this.flush();
     }
     metrics() {
-        return { documents: this.synchronizer.metrics() };
+        //return { documents: this.synchronizer.metrics() }
+        return { documents: {} };
     }
 }

package/dist/ferigan.d.ts

@@ -0,0 +1,51 @@
+import { EventEmitter } from "eventemitter3";
+import { MessageContents, RepoMessage } from "./network/messages.js";
+import { AutomergeUrl } from "./types.js";
+import { Repo } from "./Repo.js";
+export interface Ferigan extends EventEmitter<FeriganEvents> {
+    receiveMessage(message: RepoMessage): Promise<void>;
+    load(doc: ChangeLogId, since: ChangeHash[]): AsyncIterableIterator<Progress<ChangeLog | undefined>>;
+    loadCollection(doc: ChangeLogId): AsyncIterableIterator<Progress<Index | undefined>>;
+    append(doc: ChangeLogId, parents: ChangeHash[], changes: Uint8Array): Promise<void>;
+    replace(doc: ChangeLogId, start: ChangeHash, end: ChangeHash, changes: Uint8Array): Promise<void>;
+}
+export declare function makeFerigan(repo: Repo): Ferigan;
+interface FeriganEvents {
+    message: (event: {
+        message: MessageContents;
+    }) => void;
+    changed: (event: {
+        changedLog: ChangeLogId;
+    }) => void;
+    indexChanged: (event: {
+        indexUrl: ChangeLogId;
+        change: IndexChange;
+    }) => void;
+}
+type IndexChange = {
+    type: "add";
+    url: AutomergeUrl;
+};
+type ChangeLogId = string;
+type ChangeHash = string;
+type ChangeLog = {
+    start: ChangeHash;
+    end: ChangeHash;
+    changes: Uint8Array;
+};
+export type Progress<T> = {
+    type: "synchronizing_index";
+} | {
+    type: "synchronizing_docs";
+    progress: number;
+    total: number;
+} | {
+    type: "done";
+    value: T;
+};
+export type Index = {
+    rootUrl: AutomergeUrl;
+    entries: AutomergeUrl[];
+};
+export {};
+//# sourceMappingURL=ferigan.d.ts.map

package/dist/ferigan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ferigan.d.ts","sourceRoot":"","sources":["../src/ferigan.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAIhC,MAAM,WAAW,OAAQ,SAAQ,YAAY,CAAC,aAAa,CAAC;IAC1D,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnD,IAAI,CACF,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,UAAU,EAAE,GAClB,qBAAqB,CAAC,QAAQ,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAA;IACzD,cAAc,CACZ,GAAG,EAAE,WAAW,GACf,qBAAqB,CAAC,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC,CAAA;IACrD,MAAM,CACJ,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,UAAU,EAAE,EACrB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CAAA;IAChB,OAAO,CACL,GAAG,EAAE,WAAW,EAChB,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CAAA;CACjB;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CA+G/C;AAED,UAAU,aAAa;IACrB,OAAO,EAAE,CAAC,KAAK,EAAE;QAAC,OAAO,EAAE,eAAe,CAAA;KAAC,KAAK,IAAI,CAAA;IACpD,OAAO,EAAE,CAAC,KAAK,EAAE;QAAC,UAAU,EAAE,WAAW,CAAA;KAAC,KAAK,IAAI,CAAA;IACnD,YAAY,EAAE,CAAC,KAAK,EAAE;QAAC,QAAQ,EAAE,WAAW,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAC,KAAK,IAAI,CAAA;CAC5E;AAED,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,KAAK,CAAA;IACX,GAAG,EAAE,YAAY,CAAA;CAClB,CAAA;AAED,KAAK,WAAW,GAAG,MAAM,CAAA;AAEzB,KAAK,UAAU,GAAG,MAAM,CAAA;AAExB,KAAK,SAAS,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAE,CAAA;AAE5E,MAAM,MAAM,QAAQ,CAAC,CAAC,IAClB;IAAE,IAAI,EAAE,qBAAqB,CAAA;CAAE,GAC/B;IACA,IAAI,EAAE,oBAAoB,CAAA;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;CACd,GACC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAA;AAE9B,MAAM,MAAM,KAAK,GAAG;IAClB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB,CAAA"}

package/dist/ferigan.js

@@ -0,0 +1,98 @@
+import { EventEmitter } from "eventemitter3";
+const URL_RE = /automerge:([\w\d+/=]+)(?:\?([\w\d+/=&]*))*/;
+export function makeFerigan(repo) {
+    function fakeProgress() {
+        return (async function* () {
+            yield { type: "synchronizing_index" };
+        })();
+    }
+    class FakeFerigan extends EventEmitter {
+        #repo;
+        constructor(repo) {
+            super();
+            this.#repo = repo;
+        }
+        async receiveMessage(message) { }
+        load(doc) {
+            return fakeProgress();
+        }
+        async *loadCollection(doc) {
+            yield { type: "synchronizing_index" };
+            const index = { rootUrl: doc, entries: [] };
+            function findLinks(obj) {
+                const links = [];
+                const traverse = (value) => {
+                    if (typeof value === "string") {
+                        const url = parseUrl(value);
+                        if (url != null) {
+                            links.push(url);
+                        }
+                    }
+                    else if (Array.isArray(value)) {
+                        value.forEach(traverse);
+                    }
+                    else if (typeof value === "object" && value !== null) {
+                        Object.values(value).forEach(traverse);
+                    }
+                };
+                traverse(obj);
+                return links;
+            }
+            const indexDoc = this.#repo.find(doc);
+            const handlesToProcess = [indexDoc];
+            while (handlesToProcess.length > 0) {
+                const handle = handlesToProcess.pop();
+                if (!handle) {
+                    continue;
+                }
+                const doc = await handle.doc();
+                if (!doc) {
+                    continue;
+                }
+                handle.on("change", change => {
+                    for (const patch of change.patches) {
+                        if (patch.action === "splice") {
+                            const possibleUrl = parseUrl(patch.value);
+                            if (possibleUrl != null) {
+                                this.emit("indexChanged", {
+                                    indexUrl: indexDoc.url,
+                                    change: {
+                                        type: "add",
+                                        url: possibleUrl.url,
+                                    }
+                                });
+                            }
+                        }
+                    }
+                });
+                const links = findLinks(doc);
+                for (const { url: urlStr } of links) {
+                    const url = urlStr;
+                    if (index.entries.some(entry => entry === url)) {
+                        continue;
+                    }
+                    index.entries.push(url);
+                    const childHandle = this.#repo.find(url);
+                    handlesToProcess.push(childHandle);
+                }
+            }
+            yield { type: "done", value: index };
+        }
+        append(doc, parents, changes) {
+            return Promise.resolve();
+        }
+        replace(doc, start, end, changes) {
+            return Promise.resolve();
+        }
+    }
+    return new FakeFerigan(repo);
+}
+function parseUrl(urlStr) {
+    const match = urlStr.match(URL_RE);
+    if (!match) {
+        return undefined;
+    }
+    const url = new URL(match[0]);
+    const normalisedUrl = `automerge:${url.pathname}`;
+    return { url: normalisedUrl };
+}

package/dist/helpers/tests/storage-adapter-tests.d.ts

@@ -1,7 +1,7 @@
 import type { StorageAdapterInterface } from "../../storage/StorageAdapterInterface.js";
-export declare function runStorageAdapterTests(_setup: SetupFn, title?: string): void;
+export declare function runStorageAdapterTests(setup: SetupFn, title?: string): void;
 export type SetupFn = () => Promise<{
     adapter: StorageAdapterInterface;
-    teardown?: () => void;
+    teardown?: () => void | Promise<void>;
 }>;
 //# sourceMappingURL=storage-adapter-tests.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"storage-adapter-tests.d.ts","sourceRoot":"","sources":["../../../src/helpers/tests/storage-adapter-tests.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAA;AAQvF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CA+K5E;AAID,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC;IAClC,OAAO,EAAE,uBAAuB,CAAA;IAChC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAA;CACtB,CAAC,CAAA"}
+{"version":3,"file":"storage-adapter-tests.d.ts","sourceRoot":"","sources":["../../../src/helpers/tests/storage-adapter-tests.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAA;AAcvF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CA0I3E;AAID,MAAM,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC;IAClC,OAAO,EAAE,uBAAuB,CAAA;IAChC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC,CAAC,CAAA"}