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

package/dist/src/storage/StorageSubsystem.js

@@ -1,145 +0,0 @@
-import * as A from "@automerge/automerge/next"
-import * as sha256 from "fast-sha256"
-import { mergeArrays } from "../helpers/mergeArrays.js"
-import debug from "debug"
-import { headsAreSame } from "../helpers/headsAreSame.js"
-function keyHash(binary) {
-  const hash = sha256.hash(binary)
-  const hashArray = Array.from(new Uint8Array(hash)) // convert buffer to byte array
-  const hashHex = hashArray.map(b => ("00" + b.toString(16)).slice(-2)).join("") // convert bytes to hex string
-  return hashHex
-}
-function headsHash(heads) {
-  let encoder = new TextEncoder()
-  let headsbinary = mergeArrays(heads.map(h => encoder.encode(h)))
-  return keyHash(headsbinary)
-}
-export class StorageSubsystem {
-  #storageAdapter
-  #chunkInfos = new Map()
-  #storedHeads = new Map()
-  #log = debug(`automerge-repo:storage-subsystem`)
-  #snapshotting = false
-  constructor(storageAdapter) {
-    this.#storageAdapter = storageAdapter
-  }
-  async #saveIncremental(documentId, doc) {
-    const binary = A.saveSince(doc, this.#storedHeads.get(documentId) ?? [])
-    if (binary && binary.length > 0) {
-      const key = [documentId, "incremental", keyHash(binary)]
-      this.#log(`Saving incremental ${key} for document ${documentId}`)
-      await this.#storageAdapter.save(key, binary)
-      if (!this.#chunkInfos.has(documentId)) {
-        this.#chunkInfos.set(documentId, [])
-      }
-      this.#chunkInfos.get(documentId).push({
-        key,
-        type: "incremental",
-        size: binary.length,
-      })
-      this.#storedHeads.set(documentId, A.getHeads(doc))
-    } else {
-      return Promise.resolve()
-    }
-  }
-  async #saveTotal(documentId, doc, sourceChunks) {
-    this.#snapshotting = true
-    const binary = A.save(doc)
-    const snapshotHash = headsHash(A.getHeads(doc))
-    const key = [documentId, "snapshot", snapshotHash]
-    const oldKeys = new Set(
-      sourceChunks.map(c => c.key).filter(k => k[2] !== snapshotHash)
-    )
-    this.#log(`Saving snapshot ${key} for document ${documentId}`)
-    this.#log(`deleting old chunks ${Array.from(oldKeys)}`)
-    await this.#storageAdapter.save(key, binary)
-    for (const key of oldKeys) {
-      await this.#storageAdapter.remove(key)
-    }
-    const newChunkInfos =
-      this.#chunkInfos.get(documentId)?.filter(c => !oldKeys.has(c.key)) ?? []
-    newChunkInfos.push({ key, type: "snapshot", size: binary.length })
-    this.#chunkInfos.set(documentId, newChunkInfos)
-    this.#snapshotting = false
-  }
-  async loadDoc(documentId) {
-    const loaded = await this.#storageAdapter.loadRange([documentId])
-    const binaries = []
-    const chunkInfos = []
-    for (const chunk of loaded) {
-      const chunkType = chunkTypeFromKey(chunk.key)
-      if (chunkType == null) {
-        continue
-      }
-      chunkInfos.push({
-        key: chunk.key,
-        type: chunkType,
-        size: chunk.data.length,
-      })
-      binaries.push(chunk.data)
-    }
-    this.#chunkInfos.set(documentId, chunkInfos)
-    const binary = mergeArrays(binaries)
-    if (binary.length === 0) {
-      return null
-    }
-    const newDoc = A.loadIncremental(A.init(), binary)
-    this.#storedHeads.set(documentId, A.getHeads(newDoc))
-    return newDoc
-  }
-  async saveDoc(documentId, doc) {
-    if (!this.#shouldSave(documentId, doc)) {
-      return
-    }
-    let sourceChunks = this.#chunkInfos.get(documentId) ?? []
-    if (this.#shouldCompact(sourceChunks)) {
-      this.#saveTotal(documentId, doc, sourceChunks)
-    } else {
-      this.#saveIncremental(documentId, doc)
-    }
-    this.#storedHeads.set(documentId, A.getHeads(doc))
-  }
-  async remove(documentId) {
-    this.#storageAdapter.removeRange([documentId, "snapshot"])
-    this.#storageAdapter.removeRange([documentId, "incremental"])
-  }
-  #shouldSave(documentId, doc) {
-    const oldHeads = this.#storedHeads.get(documentId)
-    if (!oldHeads) {
-      return true
-    }
-    const newHeads = A.getHeads(doc)
-    if (headsAreSame(newHeads, oldHeads)) {
-      return false
-    }
-    return true
-  }
-  #shouldCompact(sourceChunks) {
-    if (this.#snapshotting) {
-      return false
-    }
-    // compact if the incremental size is greater than the snapshot size
-    let snapshotSize = 0
-    let incrementalSize = 0
-    for (const chunk of sourceChunks) {
-      if (chunk.type === "snapshot") {
-        snapshotSize += chunk.size
-      } else {
-        incrementalSize += chunk.size
-      }
-    }
-    return incrementalSize >= snapshotSize
-  }
-}
-function chunkTypeFromKey(key) {
-  if (key.length < 2) {
-    return null
-  }
-  const chunkTypeStr = key[key.length - 2]
-  if (chunkTypeStr === "snapshot" || chunkTypeStr === "incremental") {
-    const chunkType = chunkTypeStr
-    return chunkType
-  } else {
-    return null
-  }
-}

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

@@ -1,25 +0,0 @@
-import { Repo } from "../Repo.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
-  private repo
-  constructor(repo: Repo)
-  /**
-   * When we receive a sync message for a document we haven't got in memory, we
-   * register it with the repo and start synchronizing
-   */
-  receiveMessage(message: SynchronizerMessage): Promise<void>
-  /**
-   * Starts synchronizing the given document with all peers that we share it generously with.
-   */
-  addDocument(documentId: DocumentId): void
-  removeDocument(documentId: DocumentId): void
-  /** Adds a peer and maybe starts synchronizing with them */
-  addPeer(peerId: PeerId): void
-  /** Removes a peer and stops synchronizing with them */
-  removePeer(peerId: PeerId): void
-}
-//# sourceMappingURL=CollectionSynchronizer.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"CollectionSynchronizer.d.ts","sourceRoot":"","sources":["../../../src/synchronizer/CollectionSynchronizer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAOjC,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,IAAI;IAiC9B;;;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/src/synchronizer/CollectionSynchronizer.js

@@ -1,106 +0,0 @@
-import { stringifyAutomergeUrl } from "../DocUrl.js"
-import { DocSynchronizer } from "./DocSynchronizer.js"
-import { Synchronizer } from "./Synchronizer.js"
-import debug from "debug"
-const log = debug("automerge-repo:collectionsync")
-/** A CollectionSynchronizer is responsible for synchronizing a DocCollection with peers. */
-export class CollectionSynchronizer extends Synchronizer {
-  repo
-  /** The set of peers we are connected with */
-  #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
-  }
-  /** Returns a synchronizer for the given document, creating one if it doesn't already exist.  */
-  #fetchDocSynchronizer(documentId) {
-    if (!this.#docSynchronizers[documentId]) {
-      const handle = this.repo.find(stringifyAutomergeUrl({ documentId }))
-      this.#docSynchronizers[documentId] = this.#initDocSynchronizer(handle)
-    }
-    return this.#docSynchronizers[documentId]
-  }
-  /** Creates a new docSynchronizer and sets it up to propagate messages */
-  #initDocSynchronizer(handle) {
-    const docSynchronizer = new DocSynchronizer(handle)
-    docSynchronizer.on("message", event => this.emit("message", event))
-    return docSynchronizer
-  }
-  /** returns an array of peerIds that we share this document generously with */
-  async #documentGenerousPeers(documentId) {
-    const peers = Array.from(this.#peers)
-    const generousPeers = []
-    for (const peerId of peers) {
-      const okToShare = await this.repo.sharePolicy(peerId, documentId)
-      if (okToShare) generousPeers.push(peerId)
-    }
-    return generousPeers
-  }
-  // PUBLIC
-  /**
-   * 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 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")
-    }
-    this.#docSetUp[documentId] = true
-    const docSynchronizer = this.#fetchDocSynchronizer(documentId)
-    docSynchronizer.receiveMessage(message)
-    // Initiate sync with any new peers
-    const peers = await this.#documentGenerousPeers(documentId)
-    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 => {
-      docSynchronizer.beginSync(peers)
-    })
-  }
-  // TODO: implement this
-  removeDocument(documentId) {
-    throw new Error("not implemented")
-  }
-  /** 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
-      this.repo.sharePolicy(peerId, documentId).then(okToShare => {
-        if (okToShare) docSynchronizer.beginSync([peerId])
-      })
-    }
-  }
-  /** Removes a peer and stops synchronizing with them */
-  removePeer(peerId) {
-    log(`removing peer ${peerId}`)
-    this.#peers.delete(peerId)
-    for (const docSynchronizer of Object.values(this.#docSynchronizers)) {
-      docSynchronizer.endSync(peerId)
-    }
-  }
-}

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

@@ -1,29 +0,0 @@
-import { DocHandle } from "../DocHandle.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.
- */
-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(peerIds: PeerId[]): void
-  endSync(peerId: PeerId): void
-  receiveMessage(message: SynchronizerMessage): void
-  receiveEphemeralMessage(message: EphemeralMessage): void
-  receiveSyncMessage(message: SyncMessage | RequestMessage): void
-}
-export {}
-//# sourceMappingURL=DocSynchronizer.d.ts.map

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

@@ -1 +0,0 @@
-{"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/src/synchronizer/DocSynchronizer.js

@@ -1,263 +0,0 @@
-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.
- */
-export class DocSynchronizer extends Synchronizer {
-  handle
-  #log
-  #conciseLog
-  #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
-    const docId = handle.documentId.slice(0, 5)
-    this.#conciseLog = debug(`automerge-repo:concise:docsync:${docId}`) // Only logs one line per receive/send
-    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
-  }
-  /// PRIVATE
-  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) {
-    // TODO: we maybe should be persisting sync states. But we want to be careful about how often we
-    // do that, because it can generate a lot of disk activity.
-    // TODO: we only need to do this on reconnect
-    this.#syncStates[peerId] = syncState
-  }
-  #sendSyncMessage(peerId, doc) {
-    this.#log(`sendSyncMessage ->${peerId}`)
-    const syncState = this.#getSyncState(peerId)
-    const [newSyncState, message] = A.generateSyncMessage(doc, syncState)
-    this.#setSyncState(peerId, newSyncState)
-    if (message) {
-      this.#logMessage(`sendSyncMessage 🡒 ${peerId}`, message)
-      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) => {
-    // This is real expensive...
-    return
-    const size = message.byteLength
-    const logText = `${label} ${size}b`
-    const decoded = A.decodeSyncMessage(message)
-    this.#conciseLog(logText)
-    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))
-        )
-      : null
-    this.#opsLog(logText, expanded)
-  }
-  /// PUBLIC
-  hasPeer(peerId) {
-    return this.#peers.includes(peerId)
-  }
-  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)
-    })
-    // 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)
-  }
-  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, UNAVAILABLE])) {
-      this.#pendingSyncMessages.push(message)
-      return
-    }
-    this.#processAllPendingSyncMessages()
-    this.#processSyncMessage(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(message.senderId),
-        message.data
-      )
-      this.#setSyncState(message.senderId, newSyncState)
-      // respond to just this peer (as required)
-      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 message of this.#pendingSyncMessages) {
-      this.#processSyncMessage(message)
-    }
-    this.#pendingSyncMessages = []
-  }
-}

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

@@ -1,9 +0,0 @@
-import { EventEmitter } from "eventemitter3"
-import { Message, MessageContents } from "../network/messages.js"
-export declare abstract class Synchronizer extends EventEmitter<SynchronizerEvents> {
-  abstract receiveMessage(message: Message): void
-}
-export interface SynchronizerEvents {
-  message: (arg: MessageContents) => void
-}
-//# sourceMappingURL=Synchronizer.d.ts.map

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

@@ -1 +0,0 @@
-{"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/src/synchronizer/Synchronizer.js

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

package/dist/src/types.d.ts

@@ -1,16 +0,0 @@
-export type DocumentId = string & {
-  __documentId: true
-}
-export type AutomergeUrl = string & {
-  __documentUrl: true
-}
-export type BinaryDocumentId = Uint8Array & {
-  __binaryDocumentId: true
-}
-export type PeerId = string & {
-  __peerId: false
-}
-export type DistributiveOmit<T, K extends keyof any> = T extends any
-  ? Omit<T, K>
-  : never
-//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +0,0 @@
-{"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/dist/src/types.js

@@ -1 +0,0 @@
-export {}

package/dist/test/CollectionSynchronizer.test.d.ts

@@ -1,2 +0,0 @@
-export {}
-//# sourceMappingURL=CollectionSynchronizer.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"CollectionSynchronizer.test.d.ts","sourceRoot":"","sources":["../../test/CollectionSynchronizer.test.ts"],"names":[],"mappings":""}

package/dist/test/CollectionSynchronizer.test.js

@@ -1,57 +0,0 @@
-import assert from "assert"
-import { beforeEach } from "mocha"
-import { Repo } from "../src/index.js"
-import { CollectionSynchronizer } from "../src/synchronizer/CollectionSynchronizer.js"
-describe("CollectionSynchronizer", () => {
-  let repo
-  let synchronizer
-  beforeEach(() => {
-    repo = new Repo({
-      network: [],
-    })
-    synchronizer = new CollectionSynchronizer(repo)
-  })
-  it("is not null", async () => {
-    assert(synchronizer !== null)
-  })
-  it("starts synchronizing a document to peers when added", done => {
-    const handle = repo.create()
-    synchronizer.addPeer("peer1")
-    synchronizer.once("message", event => {
-      assert(event.targetId === "peer1")
-      assert(event.documentId === handle.documentId)
-      done()
-    })
-    synchronizer.addDocument(handle.documentId)
-  })
-  it("starts synchronizing existing documents when a peer is added", done => {
-    const handle = repo.create()
-    synchronizer.addDocument(handle.documentId)
-    synchronizer.once("message", event => {
-      assert(event.targetId === "peer1")
-      assert(event.documentId === handle.documentId)
-      done()
-    })
-    synchronizer.addPeer("peer1")
-  })
-  it("should not synchronize to a peer which is excluded from the share policy", done => {
-    const handle = repo.create()
-    repo.sharePolicy = async peerId => peerId !== "peer1"
-    synchronizer.addDocument(handle.documentId)
-    synchronizer.once("message", () => {
-      done(new Error("Should not have sent a message"))
-    })
-    synchronizer.addPeer("peer1")
-    setTimeout(done)
-  })
-  it("should not synchronize a document which is excluded from the share policy", done => {
-    const handle = repo.create()
-    repo.sharePolicy = async (_, documentId) => documentId !== handle.documentId
-    synchronizer.addPeer("peer2")
-    synchronizer.once("message", () => {
-      done(new Error("Should not have sent a message"))
-    })
-    synchronizer.addDocument(handle.documentId)
-    setTimeout(done)
-  })
-})