@automerge/automerge-repo 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/synchronizer/CollectionSynchronizer.d.ts

@@ -1,6 +1,7 @@
 import { DocCollection } from "../DocCollection.js";
-import { ChannelId, PeerId, DocumentId } from "../types.js";
+import { PeerId, DocumentId } from "../types.js";
 import { Synchronizer } from "./Synchronizer.js";
+import { SynchronizerMessage } from "../network/messages.js";
 /** A CollectionSynchronizer is responsible for synchronizing a DocCollection with peers. */
 export declare class CollectionSynchronizer extends Synchronizer {
     #private;
@@ -10,7 +11,7 @@ export declare class CollectionSynchronizer extends Synchronizer {
      * When we receive a sync message for a document we haven't got in memory, we
      * register it with the repo and start synchronizing
      */
-    receiveSyncMessage(peerId: PeerId, channelId: ChannelId, message: Uint8Array): Promise<void>;
+    receiveMessage(message: SynchronizerMessage): Promise<void>;
     /**
      * Starts synchronizing the given document with all peers that we share it generously with.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"CollectionSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/CollectionSynchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAOnD,OAAO,EAAE,SAAS,EAAoB,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7E,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAKhD,4FAA4F;AAC5F,qBAAa,sBAAuB,SAAQ,YAAY;;IAO1C,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,aAAa;IAiCvC;;;OAGG;IACG,kBAAkB,CACtB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU;IAmBrB;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,UAAU;IAUlC,cAAc,CAAC,UAAU,EAAE,UAAU;IAIrC,2DAA2D;IAC3D,OAAO,CAAC,MAAM,EAAE,MAAM;IAWtB,uDAAuD;IACvD,UAAU,CAAC,MAAM,EAAE,MAAM;CAQ1B"}
+{"version":3,"file":"CollectionSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/CollectionSynchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAOnD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAEhD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD,OAAO,EAGL,mBAAmB,EAEpB,MAAM,wBAAwB,CAAA;AAG/B,4FAA4F;AAC5F,qBAAa,sBAAuB,SAAQ,YAAY;;IAU1C,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,aAAa;IAiCvC;;;OAGG;IACG,cAAc,CAAC,OAAO,EAAE,mBAAmB;IAyBjD;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,UAAU;IAYlC,cAAc,CAAC,UAAU,EAAE,UAAU;IAIrC,2DAA2D;IAC3D,OAAO,CAAC,MAAM,EAAE,MAAM;IAgBtB,uDAAuD;IACvD,UAAU,CAAC,MAAM,EAAE,MAAM;CAQ1B"}

package/dist/synchronizer/CollectionSynchronizer.js

@@ -10,6 +10,8 @@ export class CollectionSynchronizer extends Synchronizer {
     #peers = new Set();
     /** A map of documentIds to their synchronizers */
     #docSynchronizers = {};
+    /** Used to determine if the document is know to the Collection and a synchronizer exists or is being set up */
+    #docSetUp = {};
     constructor(repo) {
         super();
         this.repo = repo;
@@ -44,29 +46,30 @@ export class CollectionSynchronizer extends Synchronizer {
      * When we receive a sync message for a document we haven't got in memory, we
      * register it with the repo and start synchronizing
      */
-    async receiveSyncMessage(peerId, channelId, message) {
-        log(`onSyncMessage: ${peerId}, ${channelId}, ${message.byteLength}bytes`);
-        const documentId = channelId;
+    async receiveMessage(message) {
+        log(`onSyncMessage: ${message.senderId}, ${message.documentId}, ${"data" in message ? message.data.byteLength + "bytes" : ""}`);
+        const documentId = message.documentId;
         if (!documentId) {
             throw new Error("received a message with an invalid documentId");
         }
-        const docSynchronizer = await this.#fetchDocSynchronizer(documentId);
-        await docSynchronizer.receiveSyncMessage(peerId, channelId, message);
+        this.#docSetUp[documentId] = true;
+        const docSynchronizer = this.#fetchDocSynchronizer(documentId);
+        docSynchronizer.receiveMessage(message);
         // Initiate sync with any new peers
         const peers = await this.#documentGenerousPeers(documentId);
-        peers
-            .filter(peerId => !docSynchronizer.hasPeer(peerId))
-            .forEach(peerId => docSynchronizer.beginSync(peerId));
+        docSynchronizer.beginSync(peers.filter(peerId => !docSynchronizer.hasPeer(peerId)));
     }
     /**
      * Starts synchronizing the given document with all peers that we share it generously with.
      */
     addDocument(documentId) {
+        // HACK: this is a hack to prevent us from adding the same document twice
+        if (this.#docSetUp[documentId]) {
+            return;
+        }
         const docSynchronizer = this.#fetchDocSynchronizer(documentId);
         void this.#documentGenerousPeers(documentId).then(peers => {
-            peers.forEach(peerId => {
-                docSynchronizer.beginSync(peerId);
-            });
+            docSynchronizer.beginSync(peers);
         });
     }
     // TODO: implement this
@@ -76,12 +79,15 @@ export class CollectionSynchronizer extends Synchronizer {
     /** Adds a peer and maybe starts synchronizing with them */
     addPeer(peerId) {
         log(`adding ${peerId} & synchronizing with them`);
+        if (this.#peers.has(peerId)) {
+            return;
+        }
         this.#peers.add(peerId);
         for (const docSynchronizer of Object.values(this.#docSynchronizers)) {
             const { documentId } = docSynchronizer;
-            void this.repo.sharePolicy(peerId, documentId).then(okToShare => {
+            this.repo.sharePolicy(peerId, documentId).then(okToShare => {
                 if (okToShare)
-                    docSynchronizer.beginSync(peerId);
+                    docSynchronizer.beginSync([peerId]);
             });
         }
     }

package/dist/synchronizer/DocSynchronizer.d.ts

@@ -1,6 +1,8 @@
 import { DocHandle } from "../DocHandle.js";
-import { ChannelId, PeerId } from "../types.js";
+import { PeerId } from "../types.js";
 import { Synchronizer } from "./Synchronizer.js";
+import { EphemeralMessage, RequestMessage, SynchronizerMessage, SyncMessage } from "../network/messages.js";
+type PeerDocumentStatus = "unknown" | "has" | "unavailable" | "wants";
 /**
  * DocSynchronizer takes a handle to an Automerge document, and receives & dispatches sync messages
  * to bring it inline with all other peers' versions.
@@ -9,10 +11,14 @@ export declare class DocSynchronizer extends Synchronizer {
     #private;
     private handle;
     constructor(handle: DocHandle<any>);
+    get peerStates(): Record<PeerId, PeerDocumentStatus>;
     get documentId(): import("../types.js").DocumentId;
     hasPeer(peerId: PeerId): boolean;
-    beginSync(peerId: PeerId): void;
+    beginSync(peerIds: PeerId[]): void;
     endSync(peerId: PeerId): void;
-    receiveSyncMessage(peerId: PeerId, channelId: ChannelId, message: Uint8Array): void;
+    receiveMessage(message: SynchronizerMessage): void;
+    receiveEphemeralMessage(message: EphemeralMessage): void;
+    receiveSyncMessage(message: SyncMessage | RequestMessage): void;
 }
+export {};
 //# sourceMappingURL=DocSynchronizer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"DocSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/DocSynchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAqB,MAAM,iBAAiB,CAAA;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIhD;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAanC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC;IAgB1C,IAAI,UAAU,qCAEb;IAwED,OAAO,CAAC,MAAM,EAAE,MAAM;IAItB,SAAS,CAAC,MAAM,EAAE,MAAM;IAkBxB,OAAO,CAAC,MAAM,EAAE,MAAM;IAKtB,kBAAkB,CAChB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU;CAsCtB"}
+{"version":3,"file":"DocSynchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/DocSynchronizer.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,SAAS,EAKV,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAGhD,OAAO,EACL,gBAAgB,EAIhB,cAAc,EACd,mBAAmB,EACnB,WAAW,EACZ,MAAM,wBAAwB,CAAA;AAE/B,KAAK,kBAAkB,GAAG,SAAS,GAAG,KAAK,GAAG,aAAa,GAAG,OAAO,CAAA;AAGrE;;;GAGG;AACH,qBAAa,eAAgB,SAAQ,YAAY;;IAiBnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC;IAoB1C,IAAI,UAAU,uCAEb;IAED,IAAI,UAAU,qCAEb;IAiHD,OAAO,CAAC,MAAM,EAAE,MAAM;IAItB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE;IA6B3B,OAAO,CAAC,MAAM,EAAE,MAAM;IAKtB,cAAc,CAAC,OAAO,EAAE,mBAAmB;IAkB3C,uBAAuB,CAAC,OAAO,EAAE,gBAAgB;IAuBjD,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc;CA2EzD"}

package/dist/synchronizer/DocSynchronizer.js

@@ -1,7 +1,9 @@
-import * as A from "@automerge/automerge";
-import { READY, REQUESTING } from "../DocHandle.js";
+import * as A from "@automerge/automerge/next";
+import { READY, REQUESTING, UNAVAILABLE, } from "../DocHandle.js";
 import { Synchronizer } from "./Synchronizer.js";
 import debug from "debug";
+import { isRequestMessage, } from "../network/messages.js";
+import { decode } from "cbor-x";
 /**
  * DocSynchronizer takes a handle to an Automerge document, and receives & dispatches sync messages
  * to bring it inline with all other peers' versions.
@@ -13,9 +15,11 @@ export class DocSynchronizer extends Synchronizer {
     #opsLog;
     /** Active peers */
     #peers = [];
+    #peerDocumentStatuses = {};
     /** Sync state for each peer we've communicated with (including inactive peers) */
     #syncStates = {};
     #pendingSyncMessages = [];
+    #syncStarted = false;
     constructor(handle) {
         super();
         this.handle = handle;
@@ -24,12 +28,16 @@ export class DocSynchronizer extends Synchronizer {
         this.#log = debug(`automerge-repo:docsync:${docId}`);
         this.#opsLog = debug(`automerge-repo:ops:docsync:${docId}`); // Log list of ops of each message
         handle.on("change", () => this.#syncWithPeers());
+        handle.on("ephemeral-message-outbound", payload => this.#broadcastToPeers(payload));
         // Process pending sync messages immediately after the handle becomes ready.
         void (async () => {
             await handle.doc([READY, REQUESTING]);
             this.#processAllPendingSyncMessages();
         })();
     }
+    get peerStates() {
+        return this.#peerDocumentStatuses;
+    }
     get documentId() {
         return this.handle.documentId;
     }
@@ -37,13 +45,32 @@ export class DocSynchronizer extends Synchronizer {
     async #syncWithPeers() {
         this.#log(`syncWithPeers`);
         const doc = await this.handle.doc();
+        if (doc === undefined)
+            return;
         this.#peers.forEach(peerId => this.#sendSyncMessage(peerId, doc));
     }
+    async #broadcastToPeers({ data }) {
+        this.#log(`broadcastToPeers`, this.#peers);
+        this.#peers.forEach(peerId => this.#sendEphemeralMessage(peerId, data));
+    }
+    #sendEphemeralMessage(peerId, data) {
+        this.#log(`sendEphemeralMessage ->${peerId}`);
+        this.emit("message", {
+            type: "ephemeral",
+            targetId: peerId,
+            documentId: this.handle.documentId,
+            data,
+        });
+    }
     #getSyncState(peerId) {
         if (!this.#peers.includes(peerId)) {
             this.#log("adding a new peer", peerId);
             this.#peers.push(peerId);
         }
+        // when a peer is added, we don't know if it has the document or not
+        if (!(peerId in this.#peerDocumentStatuses)) {
+            this.#peerDocumentStatuses[peerId] = "unknown";
+        }
         return this.#syncStates[peerId] ?? A.initSyncState();
     }
     #setSyncState(peerId, syncState) {
@@ -59,16 +86,32 @@ export class DocSynchronizer extends Synchronizer {
         this.#setSyncState(peerId, newSyncState);
         if (message) {
             this.#logMessage(`sendSyncMessage 🡒 ${peerId}`, message);
-            const channelId = this.handle.documentId;
-            this.emit("message", {
-                targetId: peerId,
-                channelId,
-                message,
-                broadcast: false,
-            });
-        }
-        else {
-            this.#log(`sendSyncMessage ->${peerId} [no message generated]`);
+            const decoded = A.decodeSyncMessage(message);
+            if (!this.handle.isReady() &&
+                decoded.heads.length === 0 &&
+                newSyncState.sharedHeads.length === 0 &&
+                !Object.values(this.#peerDocumentStatuses).includes("has") &&
+                this.#peerDocumentStatuses[peerId] === "unknown") {
+                // we don't have the document (or access to it), so we request it
+                this.emit("message", {
+                    type: "request",
+                    targetId: peerId,
+                    documentId: this.handle.documentId,
+                    data: message,
+                });
+            }
+            else {
+                this.emit("message", {
+                    type: "sync",
+                    targetId: peerId,
+                    data: message,
+                    documentId: this.handle.documentId,
+                });
+            }
+            // if we have sent heads, then the peer now has or will have the document
+            if (decoded.heads.length > 0) {
+                this.#peerDocumentStatuses[peerId] = "has";
+            }
         }
     }
     #logMessage = (label, message) => {
@@ -81,7 +124,7 @@ export class DocSynchronizer extends Synchronizer {
         this.#log(logText, decoded);
         // expanding is expensive, so only do it if we're logging at this level
         const expanded = this.#opsLog.enabled
-            ? decoded.changes.flatMap(change => A.decodeChange(change).ops.map(op => JSON.stringify(op)))
+            ? decoded.changes.flatMap((change) => A.decodeChange(change).ops.map((op) => JSON.stringify(op)))
             : null;
         this.#opsLog(logText, expanded);
     };
@@ -89,48 +132,120 @@ export class DocSynchronizer extends Synchronizer {
     hasPeer(peerId) {
         return this.#peers.includes(peerId);
     }
-    beginSync(peerId) {
-        this.#log(`beginSync: ${peerId}`);
-        // At this point if we don't have anything in our storage, we need to use an empty doc to sync
-        // with; but we don't want to surface that state to the front end
-        void this.handle.doc([READY, REQUESTING]).then(doc => {
-            // HACK: if we have a sync state already, we round-trip it through the encoding system to make
-            // sure state is preserved. This prevents an infinite loop caused by failed attempts to send
-            // messages during disconnection.
-            // TODO: cover that case with a test and remove this hack
+    beginSync(peerIds) {
+        this.#log(`beginSync: ${peerIds.join(", ")}`);
+        // HACK: if we have a sync state already, we round-trip it through the encoding system to make
+        // sure state is preserved. This prevents an infinite loop caused by failed attempts to send
+        // messages during disconnection.
+        // TODO: cover that case with a test and remove this hack
+        peerIds.forEach(peerId => {
             const syncStateRaw = this.#getSyncState(peerId);
             const syncState = A.decodeSyncState(A.encodeSyncState(syncStateRaw));
             this.#setSyncState(peerId, syncState);
-            this.#sendSyncMessage(peerId, doc);
+        });
+        // At this point if we don't have anything in our storage, we need to use an empty doc to sync
+        // with; but we don't want to surface that state to the front end
+        void this.handle.doc([READY, REQUESTING, UNAVAILABLE]).then(doc => {
+            // we register out peers first, then say that sync has started
+            this.#syncStarted = true;
+            this.#checkDocUnavailable();
+            if (doc === undefined)
+                return;
+            peerIds.forEach(peerId => {
+                this.#sendSyncMessage(peerId, doc);
+            });
         });
     }
     endSync(peerId) {
         this.#log(`removing peer ${peerId}`);
         this.#peers = this.#peers.filter(p => p !== peerId);
     }
-    receiveSyncMessage(peerId, channelId, message) {
-        if (channelId !== this.handle.documentId)
+    receiveMessage(message) {
+        switch (message.type) {
+            case "sync":
+            case "request":
+                this.receiveSyncMessage(message);
+                break;
+            case "ephemeral":
+                this.receiveEphemeralMessage(message);
+                break;
+            case "doc-unavailable":
+                this.#peerDocumentStatuses[message.senderId] = "unavailable";
+                this.#checkDocUnavailable();
+                break;
+            default:
+                throw new Error(`unknown message type: ${message}`);
+        }
+    }
+    receiveEphemeralMessage(message) {
+        if (message.documentId !== this.handle.documentId)
+            throw new Error(`channelId doesn't match documentId`);
+        const { senderId, data } = message;
+        const contents = decode(data);
+        this.handle.emit("ephemeral-message", {
+            handle: this.handle,
+            senderId,
+            message: contents,
+        });
+        this.#peers.forEach(peerId => {
+            if (peerId === senderId)
+                return;
+            this.emit("message", {
+                ...message,
+                targetId: peerId,
+            });
+        });
+    }
+    receiveSyncMessage(message) {
+        if (message.documentId !== this.handle.documentId)
             throw new Error(`channelId doesn't match documentId`);
         // We need to block receiving the syncMessages until we've checked local storage
-        if (!this.handle.inState([READY, REQUESTING])) {
-            this.#pendingSyncMessages.push({ peerId, message });
+        if (!this.handle.inState([READY, REQUESTING, UNAVAILABLE])) {
+            this.#pendingSyncMessages.push(message);
             return;
         }
         this.#processAllPendingSyncMessages();
-        this.#processSyncMessage(peerId, message);
+        this.#processSyncMessage(message);
     }
-    #processSyncMessage(peerId, message) {
+    #processSyncMessage(message) {
+        if (isRequestMessage(message)) {
+            this.#peerDocumentStatuses[message.senderId] = "wants";
+        }
+        this.#checkDocUnavailable();
+        // if the message has heads, then the peer has the document
+        if (A.decodeSyncMessage(message.data).heads.length > 0) {
+            this.#peerDocumentStatuses[message.senderId] = "has";
+        }
         this.handle.update(doc => {
-            const [newDoc, newSyncState] = A.receiveSyncMessage(doc, this.#getSyncState(peerId), message);
-            this.#setSyncState(peerId, newSyncState);
+            const [newDoc, newSyncState] = A.receiveSyncMessage(doc, this.#getSyncState(message.senderId), message.data);
+            this.#setSyncState(message.senderId, newSyncState);
             // respond to just this peer (as required)
-            this.#sendSyncMessage(peerId, doc);
+            this.#sendSyncMessage(message.senderId, doc);
             return newDoc;
         });
+        this.#checkDocUnavailable();
+    }
+    #checkDocUnavailable() {
+        // if we know none of the peers have the document, tell all our peers that we don't either
+        if (this.#syncStarted &&
+            this.handle.inState([REQUESTING]) &&
+            this.#peers.every(peerId => this.#peerDocumentStatuses[peerId] === "unavailable" ||
+                this.#peerDocumentStatuses[peerId] === "wants")) {
+            this.#peers
+                .filter(peerId => this.#peerDocumentStatuses[peerId] === "wants")
+                .forEach(peerId => {
+                this.emit("message", {
+                    type: "doc-unavailable",
+                    documentId: this.handle.documentId,
+                    targetId: peerId,
+                });
+            });
+            this.handle.unavailable();
+        }
     }
     #processAllPendingSyncMessages() {
-        for (const { peerId, message } of this.#pendingSyncMessages) {
-            this.#processSyncMessage(peerId, message);
+        for (const message of this.#pendingSyncMessages) {
+            this.#processSyncMessage(message);
         }
         this.#pendingSyncMessages = [];
     }

package/dist/synchronizer/Synchronizer.d.ts

@@ -1,10 +1,9 @@
-import EventEmitter from "eventemitter3";
-import { ChannelId, PeerId } from "../types.js";
-import { MessagePayload } from "../network/NetworkAdapter.js";
+import { EventEmitter } from "eventemitter3";
+import { Message, MessageContents } from "../network/messages.js";
 export declare abstract class Synchronizer extends EventEmitter<SynchronizerEvents> {
-    abstract receiveSyncMessage(peerId: PeerId, channelId: ChannelId, message: Uint8Array): void;
+    abstract receiveMessage(message: Message): void;
 }
 export interface SynchronizerEvents {
-    message: (arg: MessagePayload) => void;
+    message: (arg: MessageContents) => void;
 }
 //# sourceMappingURL=Synchronizer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/Synchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAE7D,8BAAsB,YAAa,SAAQ,YAAY,CAAC,kBAAkB,CAAC;IACzE,QAAQ,CAAC,kBAAkB,CACzB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,UAAU,GAClB,IAAI;CACR;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,IAAI,CAAA;CACvC"}
+{"version":3,"file":"Synchronizer.d.ts","sourceRoot":"","sources":["../../src/synchronizer/Synchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAEjE,8BAAsB,YAAa,SAAQ,YAAY,CAAC,kBAAkB,CAAC;IACzE,QAAQ,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;CAChD;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,CAAA;CACxC"}

package/dist/synchronizer/Synchronizer.js

@@ -1,3 +1,3 @@
-import EventEmitter from "eventemitter3";
+import { EventEmitter } from "eventemitter3";
 export class Synchronizer extends EventEmitter {
 }

package/dist/types.d.ts

@@ -10,7 +10,5 @@ export type BinaryDocumentId = Uint8Array & {
 export type PeerId = string & {
     __peerId: false;
 };
-export type ChannelId = string & {
-    __channelId: false;
-};
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,YAAY,EAAE,IAAI,CAAA;CAAE,CAAA;AACxD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,aAAa,EAAE,IAAI,CAAA;CAAE,CAAA;AAC3D,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG;IAAE,kBAAkB,EAAE,IAAI,CAAA;CAAE,CAAA;AAExE,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,EAAE,KAAK,CAAA;CAAE,CAAA;AACjD,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,KAAK,CAAA;CAAE,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG;IAAE,YAAY,EAAE,IAAI,CAAA;CAAE,CAAA;AACxD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,aAAa,EAAE,IAAI,CAAA;CAAE,CAAA;AAC3D,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG;IAAE,kBAAkB,EAAE,IAAI,CAAA;CAAE,CAAA;AAExE,MAAM,MAAM,MAAM,GAAG,MAAM,GAAG;IAAE,QAAQ,EAAE,KAAK,CAAA;CAAE,CAAA;AAEjD,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,IAAI,CAAC,SAAS,GAAG,GAChE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACV,KAAK,CAAA"}

package/fuzz/fuzz.ts

@@ -1,8 +1,8 @@
 import assert from "assert"
 import { MessageChannelNetworkAdapter } from "@automerge/automerge-repo-network-messagechannel"
-import * as Automerge from "@automerge/automerge"
+import * as Automerge from "@automerge/automerge/next"
 
-import { ChannelId, DocHandle, DocumentId, PeerId, SharePolicy } from "../src"
+import { DocHandle, DocumentId, PeerId, SharePolicy } from "../src"
 import { eventPromise } from "../src/helpers/eventPromise.js"
 import { pause } from "../src/helpers/pause.js"
 import { Repo } from "../src/Repo.js"
@@ -105,9 +105,9 @@ for (let i = 0; i < 100000; i++) {
   })
 
   await pause(0)
-  const a = await aliceRepo.find(doc.documentId).value()
-  const b = await bobRepo.find(doc.documentId).value()
-  const c = await charlieRepo.find(doc.documentId).value()
+  const a = await aliceRepo.find(doc.url).doc()
+  const b = await bobRepo.find(doc.url).doc()
+  const c = await charlieRepo.find(doc.url).doc()
   assert.deepStrictEqual(a, b, "A and B should be equal")
   assert.deepStrictEqual(b, c, "B and C should be equal")
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automerge/automerge-repo",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "description": "A repository object to manage a collection of automerge documents",
   "repository": "https://github.com/automerge/automerge-repo",
   "author": "Peter van Hardenberg <pvh@pvh.ca>",
@@ -31,7 +31,7 @@
     "typescript": "^5.1.6"
   },
   "peerDependencies": {
-    "@automerge/automerge": "^2.1.0-alpha.10"
+    "@automerge/automerge": "^2.1.0-alpha.12"
   },
   "dependencies": {
     "bs58check": "^3.0.1",
@@ -65,5 +65,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "b5830dde8f135b694809698aaad2a9fdc79a9898"
+  "gitHead": "fbf71f0c3aaa2786a4e279f336f01d665f53ce5b"
 }

package/src/DocCollection.ts

@@ -1,4 +1,4 @@
-import EventEmitter from "eventemitter3"
+import { EventEmitter } from "eventemitter3"
 import { DocHandle } from "./DocHandle.js"
 import { DocumentId, type BinaryDocumentId, AutomergeUrl } from "./types.js"
 import { type SharePolicy } from "./Repo.js"
@@ -72,9 +72,9 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
     // - pass a "reify" function that takes a `<any>` and returns `<T>`
 
     // Generate a new UUID and store it in the buffer
-    const { encodedDocumentId } = parseAutomergeUrl(generateAutomergeUrl())
-    const handle = this.#getHandle<T>(encodedDocumentId, true) as DocHandle<T>
-    this.emit("document", { handle })
+    const { documentId } = parseAutomergeUrl(generateAutomergeUrl())
+    const handle = this.#getHandle<T>(documentId, true) as DocHandle<T>
+    this.emit("document", { handle, isNew: true })
     return handle
   }
 
@@ -90,13 +90,22 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
       throw new Error(`Invalid AutomergeUrl: '${automergeUrl}'`)
     }
 
-    const { encodedDocumentId } = parseAutomergeUrl(automergeUrl)
+    const { documentId } = parseAutomergeUrl(automergeUrl)
     // If we have the handle cached, return it
-    if (this.#handleCache[encodedDocumentId])
-      return this.#handleCache[encodedDocumentId]
+    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],
+          })
+        })
+      }
+      return this.#handleCache[documentId]
+    }
 
-    const handle = this.#getHandle<T>(encodedDocumentId, false) as DocHandle<T>
-    this.emit("document", { handle })
+    const handle = this.#getHandle<T>(documentId, false) as DocHandle<T>
+    this.emit("document", { handle, isNew: false })
     return handle
   }
 
@@ -105,7 +114,7 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
     id: DocumentId | AutomergeUrl
   ) {
     if (isValidAutomergeUrl(id)) {
-      ;({ encodedDocumentId: id } = parseAutomergeUrl(id))
+      ;({ documentId: id } = parseAutomergeUrl(id))
     }
 
     const handle = this.#getHandle(id, false)
@@ -113,7 +122,7 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
 
     delete this.#handleCache[id]
     this.emit("delete-document", {
-      encodedDocumentId: id,
+      documentId: id,
     })
   }
 }
@@ -122,12 +131,14 @@ export class DocCollection extends EventEmitter<DocCollectionEvents> {
 interface DocCollectionEvents {
   document: (arg: DocumentPayload) => void
   "delete-document": (arg: DeleteDocumentPayload) => void
+  "unavailable-document": (arg: DeleteDocumentPayload) => void
 }
 
 interface DocumentPayload {
   handle: DocHandle<any>
+  isNew: boolean
 }
 
 interface DeleteDocumentPayload {
-  encodedDocumentId: DocumentId
+  documentId: DocumentId
 }