@dxos/echo-pipeline 0.6.7 → 0.6.8-main.046e6cf

package/dist/lib/browser/chunk-Q4B5JN6L.mjs

@@ -0,0 +1,2150 @@
+import "@dxos/node-std/globals";
+import {
+  Buffer,
+  createIdFromSpaceKey
+} from "./chunk-XPCF2V5U.mjs";
+
+// packages/core/echo/echo-pipeline/src/db-host/documents-synchronizer.ts
+import { UpdateScheduler } from "@dxos/async";
+import { next as A } from "@dxos/automerge/automerge";
+import { Resource } from "@dxos/context";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/documents-synchronizer.ts";
+var MAX_UPDATE_FREQ = 10;
+var DocumentsSynchronizer = class extends Resource {
+  constructor(_params) {
+    super();
+    this._params = _params;
+    this._syncStates = /* @__PURE__ */ new Map();
+    this._pendingUpdates = /* @__PURE__ */ new Set();
+    this._sendUpdatesJob = void 0;
+  }
+  addDocuments(documentIds, retryCounter = 0) {
+    if (retryCounter > 3) {
+      log.warn("Failed to load document, retry limit reached", {
+        documentIds
+      }, {
+        F: __dxlog_file,
+        L: 49,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    for (const documentId of documentIds) {
+      const doc = this._params.repo.find(documentId);
+      doc.whenReady().then(() => {
+        this._startSync(doc);
+        this._pendingUpdates.add(doc.documentId);
+        this._sendUpdatesJob.trigger();
+      }).catch((error) => {
+        log.warn("Failed to load document, wraparound", {
+          documentId,
+          error
+        }, {
+          F: __dxlog_file,
+          L: 63,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this.addDocuments([
+          documentId
+        ], retryCounter + 1);
+      });
+    }
+  }
+  removeDocuments(documentIds) {
+    for (const documentId of documentIds) {
+      this._syncStates.get(documentId)?.clearSubscriptions?.();
+      this._syncStates.delete(documentId);
+      this._pendingUpdates.delete(documentId);
+    }
+  }
+  async _open() {
+    this._sendUpdatesJob = new UpdateScheduler(this._ctx, this._checkAndSendUpdates.bind(this), {
+      maxFrequency: MAX_UPDATE_FREQ
+    });
+  }
+  async _close() {
+    await this._sendUpdatesJob.join();
+    this._syncStates.clear();
+  }
+  update(updates) {
+    for (const { documentId, mutation, isNew } of updates) {
+      if (isNew) {
+        const doc = this._params.repo.find(documentId);
+        doc.update((doc2) => A.loadIncremental(doc2, mutation));
+        this._startSync(doc);
+      } else {
+        this._writeMutation(documentId, mutation);
+      }
+    }
+  }
+  _startSync(doc) {
+    if (this._syncStates.has(doc.documentId)) {
+      log.info("Document already being synced", {
+        documentId: doc.documentId
+      }, {
+        F: __dxlog_file,
+        L: 102,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    const syncState = {
+      handle: doc
+    };
+    this._subscribeForChanges(syncState);
+    this._syncStates.set(doc.documentId, syncState);
+  }
+  _subscribeForChanges(syncState) {
+    const handler = () => {
+      this._pendingUpdates.add(syncState.handle.documentId);
+      this._sendUpdatesJob.trigger();
+    };
+    syncState.handle.on("heads-changed", handler);
+    syncState.clearSubscriptions = () => syncState.handle.off("heads-changed", handler);
+  }
+  async _checkAndSendUpdates() {
+    const updates = [];
+    const docsWithPendingUpdates = Array.from(this._pendingUpdates);
+    this._pendingUpdates.clear();
+    for (const documentId of docsWithPendingUpdates) {
+      const update = this._getPendingChanges(documentId);
+      if (update) {
+        updates.push({
+          documentId,
+          mutation: update
+        });
+      }
+    }
+    if (updates.length > 0) {
+      this._params.sendUpdates({
+        updates
+      });
+    }
+  }
+  _getPendingChanges(documentId) {
+    const syncState = this._syncStates.get(documentId);
+    invariant(syncState, "Sync state for document not found", {
+      F: __dxlog_file,
+      L: 143,
+      S: this,
+      A: [
+        "syncState",
+        "'Sync state for document not found'"
+      ]
+    });
+    const doc = syncState.handle.docSync();
+    if (!doc) {
+      return;
+    }
+    const mutation = syncState.lastSentHead ? A.saveSince(doc, syncState.lastSentHead) : A.save(doc);
+    if (mutation.length === 0) {
+      return;
+    }
+    syncState.lastSentHead = A.getHeads(doc);
+    return mutation;
+  }
+  _writeMutation(documentId, mutation) {
+    const syncState = this._syncStates.get(documentId);
+    invariant(syncState, "Sync state for document not found", {
+      F: __dxlog_file,
+      L: 158,
+      S: this,
+      A: [
+        "syncState",
+        "'Sync state for document not found'"
+      ]
+    });
+    syncState.handle.update((doc) => {
+      const headsBefore = A.getHeads(doc);
+      const newDoc = A.loadIncremental(doc, mutation);
+      if (A.equals(headsBefore, syncState.lastSentHead)) {
+        syncState.lastSentHead = A.getHeads(newDoc);
+      }
+      return newDoc;
+    });
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/collection-synchronizer.ts
+import { asyncReturn, Event, scheduleTask, scheduleTaskInterval } from "@dxos/async";
+import { next as am } from "@dxos/automerge/automerge";
+import { Resource as Resource2 } from "@dxos/context";
+import { defaultMap } from "@dxos/util";
+var MIN_QUERY_INTERVAL = 5e3;
+var POLL_INTERVAL = 3e4;
+var CollectionSynchronizer = class extends Resource2 {
+  constructor(params) {
+    super();
+    /**
+    * CollectionId -> State.
+    */
+    this._perCollectionStates = /* @__PURE__ */ new Map();
+    this._connectedPeers = /* @__PURE__ */ new Set();
+    this.remoteStateUpdated = new Event();
+    this._sendCollectionState = params.sendCollectionState;
+    this._queryCollectionState = params.queryCollectionState;
+    this._shouldSyncCollection = params.shouldSyncCollection;
+  }
+  async _open(ctx) {
+    scheduleTaskInterval(this._ctx, async () => {
+      for (const collectionId of this._perCollectionStates.keys()) {
+        this.refreshCollection(collectionId);
+        await asyncReturn();
+      }
+    }, POLL_INTERVAL);
+  }
+  getRegisteredCollectionIds() {
+    return [
+      ...this._perCollectionStates.keys()
+    ];
+  }
+  getLocalCollectionState(collectionId) {
+    return this._getPerCollectionState(collectionId).localState;
+  }
+  setLocalCollectionState(collectionId, state) {
+    this._getPerCollectionState(collectionId).localState = state;
+    queueMicrotask(async () => {
+      if (!this._ctx.disposed) {
+        this._refreshInterestedPeers(collectionId);
+        this.refreshCollection(collectionId);
+      }
+    });
+  }
+  getRemoteCollectionStates(collectionId) {
+    return this._getPerCollectionState(collectionId).remoteStates;
+  }
+  refreshCollection(collectionId) {
+    let scheduleAnotherRefresh = false;
+    const state = this._getPerCollectionState(collectionId);
+    for (const peerId of this._connectedPeers) {
+      if (state.interestedPeers.has(peerId)) {
+        const lastQueried = state.lastQueried.get(peerId) ?? 0;
+        if (Date.now() - lastQueried > MIN_QUERY_INTERVAL) {
+          state.lastQueried.set(peerId, Date.now());
+          this._queryCollectionState(collectionId, peerId);
+        } else {
+          scheduleAnotherRefresh = true;
+        }
+      }
+    }
+    if (scheduleAnotherRefresh) {
+      scheduleTask(this._ctx, () => this.refreshCollection(collectionId), MIN_QUERY_INTERVAL);
+    }
+  }
+  /**
+  * Callback when a connection to a peer is established.
+  */
+  onConnectionOpen(peerId) {
+    this._connectedPeers.add(peerId);
+    queueMicrotask(async () => {
+      if (this._ctx.disposed) {
+        return;
+      }
+      for (const [collectionId, state] of this._perCollectionStates.entries()) {
+        if (this._shouldSyncCollection(collectionId, peerId)) {
+          state.interestedPeers.add(peerId);
+          state.lastQueried.set(peerId, Date.now());
+          this._queryCollectionState(collectionId, peerId);
+        }
+      }
+    });
+  }
+  /**
+  * Callback when a connection to a peer is closed.
+  */
+  onConnectionClosed(peerId) {
+    this._connectedPeers.delete(peerId);
+    for (const perCollectionState of this._perCollectionStates.values()) {
+      perCollectionState.remoteStates.delete(peerId);
+    }
+  }
+  /**
+  * Callback when a peer queries the state of a collection.
+  */
+  onCollectionStateQueried(collectionId, peerId) {
+    const perCollectionState = this._getPerCollectionState(collectionId);
+    if (perCollectionState.localState) {
+      this._sendCollectionState(collectionId, peerId, perCollectionState.localState);
+    }
+  }
+  /**
+  * Callback when a peer sends the state of a collection.
+  */
+  onRemoteStateReceived(collectionId, peerId, state) {
+    const perCollectionState = this._getPerCollectionState(collectionId);
+    perCollectionState.remoteStates.set(peerId, state);
+    this.remoteStateUpdated.emit({
+      peerId,
+      collectionId
+    });
+  }
+  _getPerCollectionState(collectionId) {
+    return defaultMap(this._perCollectionStates, collectionId, () => ({
+      localState: void 0,
+      remoteStates: /* @__PURE__ */ new Map(),
+      interestedPeers: /* @__PURE__ */ new Set(),
+      lastQueried: /* @__PURE__ */ new Map()
+    }));
+  }
+  _refreshInterestedPeers(collectionId) {
+    for (const peerId of this._connectedPeers) {
+      if (this._shouldSyncCollection(collectionId, peerId)) {
+        this._getPerCollectionState(collectionId).interestedPeers.add(peerId);
+      } else {
+        this._getPerCollectionState(collectionId).interestedPeers.delete(peerId);
+      }
+    }
+  }
+};
+var diffCollectionState = (local, remote) => {
+  const allDocuments = /* @__PURE__ */ new Set([
+    ...Object.keys(local.documents),
+    ...Object.keys(remote.documents)
+  ]);
+  const different = [];
+  for (const documentId of allDocuments) {
+    if (!local.documents[documentId] || !remote.documents[documentId] || !am.equals(local.documents[documentId], remote.documents[documentId])) {
+      different.push(documentId);
+    }
+  }
+  return {
+    different
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/leveldb-storage-adapter.ts
+import { LifecycleState, Resource as Resource3 } from "@dxos/context";
+var LevelDBStorageAdapter = class extends Resource3 {
+  constructor(_params) {
+    super();
+    this._params = _params;
+  }
+  async load(keyArray) {
+    try {
+      if (this._lifecycleState !== LifecycleState.OPEN) {
+        return void 0;
+      }
+      const startMs = Date.now();
+      const chunk = await this._params.db.get(keyArray, {
+        ...encodingOptions
+      });
+      this._params.monitor?.recordBytesLoaded(chunk.byteLength);
+      this._params.monitor?.recordLoadDuration(Date.now() - startMs);
+      return chunk;
+    } catch (err) {
+      if (isLevelDbNotFoundError(err)) {
+        return void 0;
+      }
+      throw err;
+    }
+  }
+  async save(keyArray, binary) {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return void 0;
+    }
+    const startMs = Date.now();
+    const batch = this._params.db.batch();
+    await this._params.callbacks?.beforeSave?.({
+      path: keyArray,
+      batch
+    });
+    batch.put(keyArray, Buffer.from(binary), {
+      ...encodingOptions
+    });
+    await batch.write();
+    this._params.monitor?.recordBytesStored(binary.byteLength);
+    await this._params.callbacks?.afterSave?.(keyArray);
+    this._params.monitor?.recordStoreDuration(Date.now() - startMs);
+  }
+  async remove(keyArray) {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return void 0;
+    }
+    await this._params.db.del(keyArray, {
+      ...encodingOptions
+    });
+  }
+  async loadRange(keyPrefix) {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return [];
+    }
+    const startMs = Date.now();
+    const result = [];
+    for await (const [key, value] of this._params.db.iterator({
+      gte: keyPrefix,
+      lte: [
+        ...keyPrefix,
+        "\uFFFF"
+      ],
+      ...encodingOptions
+    })) {
+      result.push({
+        key,
+        data: value
+      });
+      this._params.monitor?.recordBytesLoaded(value.byteLength);
+    }
+    this._params.monitor?.recordLoadDuration(Date.now() - startMs);
+    return result;
+  }
+  async removeRange(keyPrefix) {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return void 0;
+    }
+    const batch = this._params.db.batch();
+    for await (const [key] of this._params.db.iterator({
+      gte: keyPrefix,
+      lte: [
+        ...keyPrefix,
+        "\uFFFF"
+      ],
+      ...encodingOptions
+    })) {
+      batch.del(key, {
+        ...encodingOptions
+      });
+    }
+    await batch.write();
+  }
+};
+var keyEncoder = {
+  encode: (key) => Buffer.from(key.map((k) => k.replaceAll("%", "%25").replaceAll("-", "%2D")).join("-")),
+  decode: (key) => Buffer.from(key).toString().split("-").map((k) => k.replaceAll("%2D", "-").replaceAll("%25", "%")),
+  format: "buffer"
+};
+var encodingOptions = {
+  keyEncoding: keyEncoder,
+  valueEncoding: "buffer"
+};
+var isLevelDbNotFoundError = (err) => err.code === "LEVEL_NOT_FOUND";
+
+// packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts
+import { Event as Event2, asyncTimeout } from "@dxos/async";
+import { getBackend, getHeads, isAutomerge, equals as headsEquals, save } from "@dxos/automerge/automerge";
+import { Repo } from "@dxos/automerge/automerge-repo";
+import { Context, Resource as Resource4, cancelWithContext } from "@dxos/context";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { PublicKey } from "@dxos/keys";
+import { log as log3 } from "@dxos/log";
+import { objectPointerCodec } from "@dxos/protocols";
+import { trace } from "@dxos/tracing";
+
+// packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts
+import { synchronized, Trigger } from "@dxos/async";
+import { NetworkAdapter } from "@dxos/automerge/automerge-repo";
+import { LifecycleState as LifecycleState2 } from "@dxos/context";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+import { nonNullable } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/automerge/network-protocol.ts
+import { MESSAGE_TYPE_COLLECTION_QUERY, MESSAGE_TYPE_COLLECTION_STATE } from "@dxos/protocols";
+var isCollectionQueryMessage = (message) => message.type === MESSAGE_TYPE_COLLECTION_QUERY;
+var isCollectionStateMessage = (message) => message.type === MESSAGE_TYPE_COLLECTION_STATE;
+
+// packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts";
+var EchoNetworkAdapter = class extends NetworkAdapter {
+  constructor(_params) {
+    super();
+    this._params = _params;
+    this._replicators = /* @__PURE__ */ new Set();
+    this._connections = /* @__PURE__ */ new Map();
+    this._lifecycleState = LifecycleState2.CLOSED;
+    this._connected = new Trigger();
+  }
+  connect(peerId, peerMetadata) {
+    this.peerId = peerId;
+    this.peerMetadata = peerMetadata;
+    this._connected.wake();
+  }
+  send(message) {
+    this._send(message);
+  }
+  disconnect() {
+  }
+  async open() {
+    if (this._lifecycleState === LifecycleState2.OPEN) {
+      return;
+    }
+    this._lifecycleState = LifecycleState2.OPEN;
+    log2("emit ready", void 0, {
+      F: __dxlog_file2,
+      L: 81,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.emit("ready", {
+      network: this
+    });
+  }
+  async close() {
+    if (this._lifecycleState === LifecycleState2.CLOSED) {
+      return this;
+    }
+    for (const replicator of this._replicators) {
+      await replicator.disconnect();
+    }
+    this._replicators.clear();
+    this._lifecycleState = LifecycleState2.CLOSED;
+  }
+  async whenConnected() {
+    await this._connected.wait({
+      timeout: 1e4
+    });
+  }
+  async addReplicator(replicator) {
+    invariant2(this._lifecycleState === LifecycleState2.OPEN, void 0, {
+      F: __dxlog_file2,
+      L: 107,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    invariant2(this.peerId, void 0, {
+      F: __dxlog_file2,
+      L: 108,
+      S: this,
+      A: [
+        "this.peerId",
+        ""
+      ]
+    });
+    invariant2(!this._replicators.has(replicator), void 0, {
+      F: __dxlog_file2,
+      L: 109,
+      S: this,
+      A: [
+        "!this._replicators.has(replicator)",
+        ""
+      ]
+    });
+    this._replicators.add(replicator);
+    await replicator.connect({
+      peerId: this.peerId,
+      onConnectionOpen: this._onConnectionOpen.bind(this),
+      onConnectionClosed: this._onConnectionClosed.bind(this),
+      onConnectionAuthScopeChanged: this._onConnectionAuthScopeChanged.bind(this),
+      isDocumentInRemoteCollection: this._params.isDocumentInRemoteCollection,
+      getContainingSpaceForDocument: this._params.getContainingSpaceForDocument,
+      getContainingSpaceIdForDocument: async (documentId) => {
+        const key = await this._params.getContainingSpaceForDocument(documentId);
+        return key ? createIdFromSpaceKey(key) : null;
+      }
+    });
+  }
+  async removeReplicator(replicator) {
+    invariant2(this._lifecycleState === LifecycleState2.OPEN, void 0, {
+      F: __dxlog_file2,
+      L: 128,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    invariant2(this._replicators.has(replicator), void 0, {
+      F: __dxlog_file2,
+      L: 129,
+      S: this,
+      A: [
+        "this._replicators.has(replicator)",
+        ""
+      ]
+    });
+    await replicator.disconnect();
+    this._replicators.delete(replicator);
+  }
+  async shouldAdvertise(peerId, params) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      return false;
+    }
+    return connection.connection.shouldAdvertise(params);
+  }
+  shouldSyncCollection(peerId, params) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      return false;
+    }
+    return connection.connection.shouldSyncCollection(params);
+  }
+  queryCollectionState(collectionId, targetId) {
+    const message = {
+      type: "collection-query",
+      senderId: this.peerId,
+      targetId,
+      collectionId
+    };
+    this._send(message);
+  }
+  sendCollectionState(collectionId, targetId, state) {
+    const message = {
+      type: "collection-state",
+      senderId: this.peerId,
+      targetId,
+      collectionId,
+      state
+    };
+    this._send(message);
+  }
+  _send(message) {
+    const connectionEntry = this._connections.get(message.targetId);
+    if (!connectionEntry) {
+      throw new Error("Connection not found.");
+    }
+    const writeStart = Date.now();
+    connectionEntry.writer.write(message).then(() => {
+      const durationMs = Date.now() - writeStart;
+      this._params.monitor?.recordMessageSent(message, durationMs);
+    }).catch((err) => {
+      if (connectionEntry.isOpen) {
+        log2.catch(err, void 0, {
+          F: __dxlog_file2,
+          L: 189,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      this._params.monitor?.recordMessageSendingFailed(message);
+    });
+  }
+  // TODO(dmaretskyi): Remove.
+  getPeersInterestedInCollection(collectionId) {
+    return Array.from(this._connections.values()).map((connection) => {
+      return connection.connection.shouldSyncCollection({
+        collectionId
+      }) ? connection.connection.peerId : null;
+    }).filter(nonNullable);
+  }
+  _onConnectionOpen(connection) {
+    log2("Connection opened", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file2,
+      L: 207,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    invariant2(!this._connections.has(connection.peerId), void 0, {
+      F: __dxlog_file2,
+      L: 208,
+      S: this,
+      A: [
+        "!this._connections.has(connection.peerId as PeerId)",
+        ""
+      ]
+    });
+    const reader = connection.readable.getReader();
+    const writer = connection.writable.getWriter();
+    const connectionEntry = {
+      connection,
+      reader,
+      writer,
+      isOpen: true
+    };
+    this._connections.set(connection.peerId, connectionEntry);
+    queueMicrotask(async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          this._onMessage(value);
+        }
+      } catch (err) {
+        if (connectionEntry.isOpen) {
+          log2.catch(err, void 0, {
+            F: __dxlog_file2,
+            L: 227,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    log2("emit peer-candidate", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file2,
+      L: 232,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._emitPeerCandidate(connection);
+    this._params.monitor?.recordPeerConnected(connection.peerId);
+  }
+  _onMessage(message) {
+    if (isCollectionQueryMessage(message)) {
+      this._params.onCollectionStateQueried(message.collectionId, message.senderId);
+    } else if (isCollectionStateMessage(message)) {
+      this._params.onCollectionStateReceived(message.collectionId, message.senderId, message.state);
+    } else {
+      this.emit("message", message);
+    }
+    this._params.monitor?.recordMessageReceived(message);
+  }
+  /**
+  * Trigger doc-synchronizer shared documents set recalculation. Happens on peer-candidate.
+  * TODO(y): replace with a proper API call when sharePolicy update becomes supported by automerge-repo
+  */
+  _onConnectionAuthScopeChanged(connection) {
+    log2("Connection auth scope changed", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file2,
+      L: 253,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const entry = this._connections.get(connection.peerId);
+    invariant2(entry, void 0, {
+      F: __dxlog_file2,
+      L: 255,
+      S: this,
+      A: [
+        "entry",
+        ""
+      ]
+    });
+    this.emit("peer-disconnected", {
+      peerId: connection.peerId
+    });
+    this._emitPeerCandidate(connection);
+  }
+  _onConnectionClosed(connection) {
+    log2("Connection closed", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file2,
+      L: 261,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const entry = this._connections.get(connection.peerId);
+    invariant2(entry, void 0, {
+      F: __dxlog_file2,
+      L: 263,
+      S: this,
+      A: [
+        "entry",
+        ""
+      ]
+    });
+    entry.isOpen = false;
+    this.emit("peer-disconnected", {
+      peerId: connection.peerId
+    });
+    this._params.monitor?.recordPeerDisconnected(connection.peerId);
+    void entry.reader.cancel().catch((err) => log2.catch(err, void 0, {
+      F: __dxlog_file2,
+      L: 269,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+    void entry.writer.abort().catch((err) => log2.catch(err, void 0, {
+      F: __dxlog_file2,
+      L: 270,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+    this._connections.delete(connection.peerId);
+  }
+  _emitPeerCandidate(connection) {
+    this.emit("peer-candidate", {
+      peerId: connection.peerId,
+      peerMetadata: createEchoPeerMetadata()
+    });
+  }
+};
+_ts_decorate([
+  synchronized
+], EchoNetworkAdapter.prototype, "open", null);
+_ts_decorate([
+  synchronized
+], EchoNetworkAdapter.prototype, "close", null);
+_ts_decorate([
+  synchronized
+], EchoNetworkAdapter.prototype, "addReplicator", null);
+_ts_decorate([
+  synchronized
+], EchoNetworkAdapter.prototype, "removeReplicator", null);
+var createEchoPeerMetadata = () => ({
+  // TODO(dmaretskyi): Refactor this.
+  dxos_peerSource: "EchoNetworkAdapter"
+});
+var isEchoPeerMetadata = (metadata) => metadata?.dxos_peerSource === "EchoNetworkAdapter";
+
+// packages/core/echo/echo-pipeline/src/automerge/heads-store.ts
+import { headsEncoding } from "@dxos/indexing";
+var HeadsStore = class {
+  constructor({ db }) {
+    this._db = db;
+  }
+  setHeads(documentId, heads, batch) {
+    batch.put(documentId, heads, {
+      sublevel: this._db,
+      keyEncoding: "utf8",
+      valueEncoding: headsEncoding
+    });
+  }
+  // TODO(dmaretskyi): Make batched.
+  async getHeads(documentIds) {
+    return this._db.getMany(documentIds, {
+      keyEncoding: "utf8",
+      valueEncoding: headsEncoding
+    });
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
+var AutomergeHost = class extends Resource4 {
+  constructor({ db, indexMetadataStore, dataMonitor }) {
+    super();
+    this._collectionSynchronizer = new CollectionSynchronizer({
+      queryCollectionState: this._queryCollectionState.bind(this),
+      sendCollectionState: this._sendCollectionState.bind(this),
+      shouldSyncCollection: this._shouldSyncCollection.bind(this)
+    });
+    this._db = db;
+    this._storage = new LevelDBStorageAdapter({
+      db: db.sublevel("automerge"),
+      callbacks: {
+        beforeSave: async (params) => this._beforeSave(params),
+        afterSave: async (key) => this._afterSave(key)
+      },
+      monitor: dataMonitor
+    });
+    this._echoNetworkAdapter = new EchoNetworkAdapter({
+      getContainingSpaceForDocument: this._getContainingSpaceForDocument.bind(this),
+      isDocumentInRemoteCollection: this._isDocumentInRemoteCollection.bind(this),
+      onCollectionStateQueried: this._onCollectionStateQueried.bind(this),
+      onCollectionStateReceived: this._onCollectionStateReceived.bind(this),
+      monitor: dataMonitor
+    });
+    this._headsStore = new HeadsStore({
+      db: db.sublevel("heads")
+    });
+    this._indexMetadataStore = indexMetadataStore;
+  }
+  async _open() {
+    this._peerId = `host-${PublicKey.random().toHex()}`;
+    await this._storage.open?.();
+    this._repo = new Repo({
+      peerId: this._peerId,
+      sharePolicy: this._sharePolicy.bind(this),
+      storage: this._storage,
+      network: [
+        // Upstream swarm.
+        this._echoNetworkAdapter
+      ]
+    });
+    Event2.wrap(this._echoNetworkAdapter, "peer-candidate").on(this._ctx, (e) => this._onPeerConnected(e.peerId));
+    Event2.wrap(this._echoNetworkAdapter, "peer-disconnected").on(this._ctx, (e) => this._onPeerDisconnected(e.peerId));
+    this._collectionSynchronizer.remoteStateUpdated.on(this._ctx, ({ collectionId, peerId }) => {
+      this._onRemoteCollectionStateUpdated(collectionId, peerId);
+    });
+    await this._echoNetworkAdapter.open();
+    await this._collectionSynchronizer.open();
+    await this._echoNetworkAdapter.open();
+    await this._echoNetworkAdapter.whenConnected();
+  }
+  async _close() {
+    await this._collectionSynchronizer.close();
+    await this._storage.close?.();
+    await this._echoNetworkAdapter.close();
+    await this._ctx.dispose();
+  }
+  /**
+  * @deprecated To be abstracted away.
+  */
+  get repo() {
+    return this._repo;
+  }
+  get peerId() {
+    return this._peerId;
+  }
+  get loadedDocsCount() {
+    return Object.keys(this._repo.handles).length;
+  }
+  async addReplicator(replicator) {
+    await this._echoNetworkAdapter.addReplicator(replicator);
+  }
+  async removeReplicator(replicator) {
+    await this._echoNetworkAdapter.removeReplicator(replicator);
+  }
+  /**
+  * Loads the document handle from the repo and waits for it to be ready.
+  */
+  async loadDoc(ctx, documentId, opts) {
+    let handle;
+    if (typeof documentId === "string") {
+      handle = this._repo.handles[documentId];
+    }
+    if (!handle) {
+      handle = this._repo.find(documentId);
+    }
+    if (!handle.isReady()) {
+      if (!opts?.timeout) {
+        await cancelWithContext(ctx, handle.whenReady());
+      } else {
+        await cancelWithContext(ctx, asyncTimeout(handle.whenReady(), opts.timeout));
+      }
+    }
+    return handle;
+  }
+  /**
+  * Create new persisted document.
+  */
+  createDoc(initialValue, opts) {
+    if (opts?.preserveHistory) {
+      if (!isAutomerge(initialValue)) {
+        throw new TypeError("Initial value must be an Automerge document");
+      }
+      return this._repo.import(save(initialValue));
+    } else {
+      return this._repo.create(initialValue);
+    }
+  }
+  async waitUntilHeadsReplicated(heads) {
+    const entries = heads.entries;
+    if (!entries?.length) {
+      return;
+    }
+    const documentIds = entries.map((entry) => entry.documentId);
+    const documentHeads = await this.getHeads(documentIds);
+    const headsToWait = entries.filter((entry, index) => {
+      const targetHeads = entry.heads;
+      if (!targetHeads || targetHeads.length === 0) {
+        return false;
+      }
+      const currentHeads = documentHeads[index];
+      return !(currentHeads !== null && headsEquals(currentHeads, targetHeads));
+    });
+    if (headsToWait.length > 0) {
+      await Promise.all(headsToWait.map(async (entry, index) => {
+        const handle = await this.loadDoc(Context.default(void 0, {
+          F: __dxlog_file3,
+          L: 227
+        }), entry.documentId);
+        await waitForHeads(handle, entry.heads);
+      }));
+    }
+    await this._repo.flush(documentIds.filter((documentId) => !!this._repo.handles[documentId]));
+  }
+  async reIndexHeads(documentIds) {
+    for (const documentId of documentIds) {
+      log3.info("re-indexing heads for document", {
+        documentId
+      }, {
+        F: __dxlog_file3,
+        L: 239,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const handle = this._repo.find(documentId);
+      await handle.whenReady([
+        "ready",
+        "requesting"
+      ]);
+      if (handle.inState([
+        "requesting"
+      ])) {
+        log3.warn("document is not available locally, skipping", {
+          documentId
+        }, {
+          F: __dxlog_file3,
+          L: 243,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const doc = handle.docSync();
+      invariant3(doc, void 0, {
+        F: __dxlog_file3,
+        L: 248,
+        S: this,
+        A: [
+          "doc",
+          ""
+        ]
+      });
+      const heads = getHeads(doc);
+      const batch = this._db.batch();
+      this._headsStore.setHeads(documentId, heads, batch);
+      await batch.write();
+    }
+    log3.info("done re-indexing heads", void 0, {
+      F: __dxlog_file3,
+      L: 255,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
+  // Hosts, running in the worker, don't share documents unless requested by other peers.
+  // NOTE: If both peers return sharePolicy=false the replication will not happen
+  // https://github.com/automerge/automerge-repo/pull/292
+  async _sharePolicy(peerId, documentId) {
+    if (peerId.startsWith("client-")) {
+      return false;
+    }
+    if (!documentId) {
+      return false;
+    }
+    const peerMetadata = this.repo.peerMetadataByPeerId[peerId];
+    if (isEchoPeerMetadata(peerMetadata)) {
+      return this._echoNetworkAdapter.shouldAdvertise(peerId, {
+        documentId
+      });
+    }
+    return false;
+  }
+  async _beforeSave({ path, batch }) {
+    const handle = this._repo.handles[path[0]];
+    if (!handle) {
+      return;
+    }
+    const doc = handle.docSync();
+    if (!doc) {
+      return;
+    }
+    const heads = getHeads(doc);
+    this._headsStore.setHeads(handle.documentId, heads, batch);
+    const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+    const objectIds = Object.keys(doc.objects ?? {});
+    const encodedIds = objectIds.map((objectId) => objectPointerCodec.encode({
+      documentId: handle.documentId,
+      objectId,
+      spaceKey
+    }));
+    const idToLastHash = new Map(encodedIds.map((id) => [
+      id,
+      heads
+    ]));
+    this._indexMetadataStore.markDirty(idToLastHash, batch);
+  }
+  _shouldSyncCollection(collectionId, peerId) {
+    const peerMetadata = this._repo.peerMetadataByPeerId[peerId];
+    if (isEchoPeerMetadata(peerMetadata)) {
+      return this._echoNetworkAdapter.shouldSyncCollection(peerId, {
+        collectionId
+      });
+    }
+    return false;
+  }
+  /**
+  * Called by AutomergeStorageAdapter after levelDB batch commit.
+  */
+  async _afterSave(path) {
+    this._indexMetadataStore.notifyMarkedDirty();
+    const documentId = path[0];
+    const document = this._repo.handles[documentId]?.docSync();
+    if (document) {
+      const heads = getHeads(document);
+      this._onHeadsChanged(documentId, heads);
+    }
+  }
+  _automergePeers() {
+    return this._repo.peers;
+  }
+  async _isDocumentInRemoteCollection(params) {
+    for (const collectionId of this._collectionSynchronizer.getRegisteredCollectionIds()) {
+      const remoteCollections = this._collectionSynchronizer.getRemoteCollectionStates(collectionId);
+      const remotePeerDocs = remoteCollections.get(params.peerId)?.documents;
+      if (remotePeerDocs && params.documentId in remotePeerDocs) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async _getContainingSpaceForDocument(documentId) {
+    const doc = this._repo.handles[documentId]?.docSync();
+    if (!doc) {
+      return null;
+    }
+    const spaceKeyHex = getSpaceKeyFromDoc(doc);
+    if (!spaceKeyHex) {
+      return null;
+    }
+    return PublicKey.from(spaceKeyHex);
+  }
+  /**
+  * Flush documents to disk.
+  */
+  async flush({ documentIds } = {}) {
+    await this._repo.flush(documentIds);
+  }
+  async getHeads(documentIds) {
+    const result = [];
+    const storeRequestIds = [];
+    const storeResultIndices = [];
+    for (const documentId of documentIds) {
+      const doc = this._repo.handles[documentId]?.docSync();
+      if (doc) {
+        result.push(getHeads(doc));
+      } else {
+        storeRequestIds.push(documentId);
+        storeResultIndices.push(result.length);
+        result.push(void 0);
+      }
+    }
+    if (storeRequestIds.length > 0) {
+      const storedHeads = await this._headsStore.getHeads(storeRequestIds);
+      for (let i = 0; i < storedHeads.length; i++) {
+        result[storeResultIndices[i]] = storedHeads[i];
+      }
+    }
+    return result;
+  }
+  //
+  // Collection sync.
+  //
+  getLocalCollectionState(collectionId) {
+    return this._collectionSynchronizer.getLocalCollectionState(collectionId);
+  }
+  getRemoteCollectionStates(collectionId) {
+    return this._collectionSynchronizer.getRemoteCollectionStates(collectionId);
+  }
+  refreshCollection(collectionId) {
+    this._collectionSynchronizer.refreshCollection(collectionId);
+  }
+  async getCollectionSyncState(collectionId) {
+    const result = {
+      peers: []
+    };
+    const localState = this.getLocalCollectionState(collectionId);
+    const remoteState = this.getRemoteCollectionStates(collectionId);
+    if (!localState) {
+      return result;
+    }
+    for (const [peerId, state] of remoteState) {
+      const diff = diffCollectionState(localState, state);
+      result.peers.push({
+        peerId,
+        differentDocuments: diff.different.length
+      });
+    }
+    return result;
+  }
+  /**
+  * Update the local collection state based on the locally stored document heads.
+  */
+  async updateLocalCollectionState(collectionId, documentIds) {
+    const heads = await this.getHeads(documentIds);
+    const documents = Object.fromEntries(heads.map((heads2, index) => [
+      documentIds[index],
+      heads2 ?? []
+    ]));
+    this._collectionSynchronizer.setLocalCollectionState(collectionId, {
+      documents
+    });
+  }
+  _onCollectionStateQueried(collectionId, peerId) {
+    this._collectionSynchronizer.onCollectionStateQueried(collectionId, peerId);
+  }
+  _onCollectionStateReceived(collectionId, peerId, state) {
+    this._collectionSynchronizer.onRemoteStateReceived(collectionId, peerId, decodeCollectionState(state));
+  }
+  _queryCollectionState(collectionId, peerId) {
+    this._echoNetworkAdapter.queryCollectionState(collectionId, peerId);
+  }
+  _sendCollectionState(collectionId, peerId, state) {
+    this._echoNetworkAdapter.sendCollectionState(collectionId, peerId, encodeCollectionState(state));
+  }
+  _onPeerConnected(peerId) {
+    this._collectionSynchronizer.onConnectionOpen(peerId);
+  }
+  _onPeerDisconnected(peerId) {
+    this._collectionSynchronizer.onConnectionClosed(peerId);
+  }
+  _onRemoteCollectionStateUpdated(collectionId, peerId) {
+    const localState = this._collectionSynchronizer.getLocalCollectionState(collectionId);
+    const remoteState = this._collectionSynchronizer.getRemoteCollectionStates(collectionId).get(peerId);
+    if (!localState || !remoteState) {
+      return;
+    }
+    const { different } = diffCollectionState(localState, remoteState);
+    if (different.length === 0) {
+      return;
+    }
+    log3.info("replication documents after collection sync", {
+      count: different.length
+    }, {
+      F: __dxlog_file3,
+      L: 475,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    for (const documentId of different) {
+      this._repo.find(documentId);
+    }
+  }
+  _onHeadsChanged(documentId, heads) {
+    for (const collectionId of this._collectionSynchronizer.getRegisteredCollectionIds()) {
+      const state = this._collectionSynchronizer.getLocalCollectionState(collectionId);
+      if (state?.documents[documentId]) {
+        const newState = structuredClone(state);
+        newState.documents[documentId] = heads;
+        this._collectionSynchronizer.setLocalCollectionState(collectionId, newState);
+      }
+    }
+  }
+};
+_ts_decorate2([
+  trace.info()
+], AutomergeHost.prototype, "_peerId", void 0);
+_ts_decorate2([
+  trace.info({
+    depth: null
+  })
+], AutomergeHost.prototype, "_automergePeers", null);
+_ts_decorate2([
+  trace.span({
+    showInBrowserTimeline: true
+  })
+], AutomergeHost.prototype, "flush", null);
+AutomergeHost = _ts_decorate2([
+  trace.resource()
+], AutomergeHost);
+var getSpaceKeyFromDoc = (doc) => {
+  const rawSpaceKey = doc.access?.spaceKey ?? doc.experimental_spaceKey;
+  if (rawSpaceKey == null) {
+    return null;
+  }
+  return String(rawSpaceKey);
+};
+var waitForHeads = async (handle, heads) => {
+  const unavailableHeads = new Set(heads);
+  await handle.whenReady();
+  await Event2.wrap(handle, "change").waitForCondition(() => {
+    for (const changeHash of unavailableHeads.values()) {
+      if (changeIsPresentInDoc(handle.docSync(), changeHash)) {
+        unavailableHeads.delete(changeHash);
+      }
+    }
+    return unavailableHeads.size === 0;
+  });
+};
+var changeIsPresentInDoc = (doc, changeHash) => {
+  return !!getBackend(doc).getChangeByHash(changeHash);
+};
+var decodeCollectionState = (state) => {
+  invariant3(typeof state === "object" && state !== null, "Invalid state", {
+    F: __dxlog_file3,
+    L: 528,
+    S: void 0,
+    A: [
+      "typeof state === 'object' && state !== null",
+      "'Invalid state'"
+    ]
+  });
+  return state;
+};
+var encodeCollectionState = (state) => {
+  return state;
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/space-collection.ts
+import { invariant as invariant4 } from "@dxos/invariant";
+import { SpaceId } from "@dxos/keys";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/space-collection.ts";
+var deriveCollectionIdFromSpaceId = (spaceId) => `space:${spaceId}`;
+var getSpaceIdFromCollectionId = (collectionId) => {
+  const spaceId = collectionId.replace(/^space:/, "");
+  invariant4(SpaceId.isValid(spaceId), void 0, {
+    F: __dxlog_file4,
+    L: 12,
+    S: void 0,
+    A: [
+      "SpaceId.isValid(spaceId)",
+      ""
+    ]
+  });
+  return spaceId;
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts
+import { invariant as invariant6 } from "@dxos/invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log5 } from "@dxos/log";
+import { ComplexSet, defaultMap as defaultMap2 } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator-connection.ts
+import * as A2 from "@dxos/automerge/automerge";
+import { cbor } from "@dxos/automerge/automerge-repo";
+import { Resource as Resource5 } from "@dxos/context";
+import { invariant as invariant5 } from "@dxos/invariant";
+import { log as log4 } from "@dxos/log";
+import { AutomergeReplicator } from "@dxos/teleport-extension-automerge-replicator";
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator-connection.ts";
+var DEFAULT_FACTORY = (params) => new AutomergeReplicator(...params);
+var MeshReplicatorConnection = class extends Resource5 {
+  constructor(_params) {
+    super();
+    this._params = _params;
+    this.remoteDeviceKey = null;
+    this._remotePeerId = null;
+    this._isEnabled = false;
+    let readableStreamController;
+    this.readable = new ReadableStream({
+      start: (controller) => {
+        readableStreamController = controller;
+        this._ctx.onDispose(() => controller.close());
+      }
+    });
+    this.writable = new WritableStream({
+      write: async (message, controller) => {
+        invariant5(this._isEnabled, "Writing to a disabled connection", {
+          F: __dxlog_file5,
+          L: 49,
+          S: this,
+          A: [
+            "this._isEnabled",
+            "'Writing to a disabled connection'"
+          ]
+        });
+        try {
+          logSendSync(message);
+          await this.replicatorExtension.sendSyncMessage({
+            payload: cbor.encode(message)
+          });
+        } catch (err) {
+          controller.error(err);
+          this._disconnectIfEnabled();
+        }
+      }
+    });
+    const createAutomergeReplicator = this._params.replicatorFactory ?? DEFAULT_FACTORY;
+    this.replicatorExtension = createAutomergeReplicator([
+      {
+        peerId: this._params.ownPeerId
+      },
+      {
+        onStartReplication: async (info, remotePeerId) => {
+          this.remoteDeviceKey = remotePeerId;
+          this._remotePeerId = info.id;
+          log4("onStartReplication", {
+            id: info.id,
+            thisPeerId: this.peerId,
+            remotePeerId: remotePeerId.toHex()
+          }, {
+            F: __dxlog_file5,
+            L: 84,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._params.onRemoteConnected();
+        },
+        onSyncMessage: async ({ payload }) => {
+          if (!this._isEnabled) {
+            return;
+          }
+          const message = cbor.decode(payload);
+          readableStreamController.enqueue(message);
+        },
+        onClose: async () => {
+          this._disconnectIfEnabled();
+        }
+      }
+    ]);
+  }
+  _disconnectIfEnabled() {
+    if (this._isEnabled) {
+      this._params.onRemoteDisconnected();
+    }
+  }
+  get peerId() {
+    invariant5(this._remotePeerId != null, "Remote peer has not connected yet.", {
+      F: __dxlog_file5,
+      L: 110,
+      S: this,
+      A: [
+        "this._remotePeerId != null",
+        "'Remote peer has not connected yet.'"
+      ]
+    });
+    return this._remotePeerId;
+  }
+  async shouldAdvertise(params) {
+    return this._params.shouldAdvertise(params);
+  }
+  shouldSyncCollection(params) {
+    return this._params.shouldSyncCollection(params);
+  }
+  /**
+  * Start exchanging messages with the remote peer.
+  * Call after the remote peer has connected.
+  */
+  enable() {
+    invariant5(this._remotePeerId != null, "Remote peer has not connected yet.", {
+      F: __dxlog_file5,
+      L: 127,
+      S: this,
+      A: [
+        "this._remotePeerId != null",
+        "'Remote peer has not connected yet.'"
+      ]
+    });
+    this._isEnabled = true;
+  }
+  /**
+  * Stop exchanging messages with the remote peer.
+  */
+  disable() {
+    this._isEnabled = false;
+  }
+};
+var logSendSync = (message) => {
+  log4("sendSyncMessage", () => {
+    const decodedSyncMessage = message.type === "sync" && message.data ? A2.decodeSyncMessage(message.data) : void 0;
+    return {
+      sync: decodedSyncMessage && {
+        headsLength: decodedSyncMessage.heads.length,
+        requesting: decodedSyncMessage.need.length > 0,
+        sendingChanges: decodedSyncMessage.changes.length > 0
+      },
+      type: message.type,
+      from: message.senderId,
+      to: message.targetId
+    };
+  }, {
+    F: __dxlog_file5,
+    L: 140,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts";
+var MeshEchoReplicator = class {
+  constructor() {
+    this._connections = /* @__PURE__ */ new Set();
+    /**
+    * Using automerge peerId as a key.
+    */
+    this._connectionsPerPeer = /* @__PURE__ */ new Map();
+    /**
+    * spaceId -> deviceKey[]
+    */
+    this._authorizedDevices = /* @__PURE__ */ new Map();
+    this._context = null;
+  }
+  async connect(context) {
+    this._context = context;
+  }
+  async disconnect() {
+    for (const connection of this._connectionsPerPeer.values()) {
+      this._context?.onConnectionClosed(connection);
+    }
+    for (const connection of this._connections) {
+      await connection.close();
+    }
+    this._connections.clear();
+    this._connectionsPerPeer.clear();
+    this._context = null;
+  }
+  createExtension(extensionFactory) {
+    invariant6(this._context, void 0, {
+      F: __dxlog_file6,
+      L: 56,
+      S: this,
+      A: [
+        "this._context",
+        ""
+      ]
+    });
+    const connection = new MeshReplicatorConnection({
+      ownPeerId: this._context.peerId,
+      replicatorFactory: extensionFactory,
+      onRemoteConnected: async () => {
+        log5("onRemoteConnected", {
+          peerId: connection.peerId
+        }, {
+          F: __dxlog_file6,
+          L: 62,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        invariant6(this._context, void 0, {
+          F: __dxlog_file6,
+          L: 63,
+          S: this,
+          A: [
+            "this._context",
+            ""
+          ]
+        });
+        if (this._connectionsPerPeer.has(connection.peerId)) {
+          this._context.onConnectionAuthScopeChanged(connection);
+        } else {
+          this._connectionsPerPeer.set(connection.peerId, connection);
+          this._context.onConnectionOpen(connection);
+          connection.enable();
+        }
+      },
+      onRemoteDisconnected: async () => {
+        log5("onRemoteDisconnected", {
+          peerId: connection.peerId
+        }, {
+          F: __dxlog_file6,
+          L: 74,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._context?.onConnectionClosed(connection);
+        this._connectionsPerPeer.delete(connection.peerId);
+        connection.disable();
+        this._connections.delete(connection);
+      },
+      shouldAdvertise: async (params) => {
+        log5("shouldAdvertise", {
+          peerId: connection.peerId,
+          documentId: params.documentId
+        }, {
+          F: __dxlog_file6,
+          L: 81,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        invariant6(this._context, void 0, {
+          F: __dxlog_file6,
+          L: 82,
+          S: this,
+          A: [
+            "this._context",
+            ""
+          ]
+        });
+        try {
+          const spaceKey = await this._context.getContainingSpaceForDocument(params.documentId);
+          if (!spaceKey) {
+            const remoteDocumentExists = await this._context.isDocumentInRemoteCollection({
+              documentId: params.documentId,
+              peerId: connection.peerId
+            });
+            log5("document not found locally for share policy check, accepting the remote document", {
+              peerId: connection.peerId,
+              documentId: params.documentId,
+              remoteDocumentExists
+            }, {
+              F: __dxlog_file6,
+              L: 90,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return remoteDocumentExists;
+          }
+          const spaceId = await createIdFromSpaceKey(spaceKey);
+          const authorizedDevices = this._authorizedDevices.get(spaceId);
+          if (!connection.remoteDeviceKey) {
+            log5("device key not found for share policy check", {
+              peerId: connection.peerId,
+              documentId: params.documentId
+            }, {
+              F: __dxlog_file6,
+              L: 106,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return false;
+          }
+          const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
+          log5("share policy check", {
+            localPeer: this._context.peerId,
+            remotePeer: connection.peerId,
+            documentId: params.documentId,
+            deviceKey: connection.remoteDeviceKey,
+            spaceKey,
+            isAuthorized
+          }, {
+            F: __dxlog_file6,
+            L: 114,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return isAuthorized;
+        } catch (err) {
+          log5.catch(err, void 0, {
+            F: __dxlog_file6,
+            L: 124,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return false;
+        }
+      },
+      shouldSyncCollection: ({ collectionId }) => {
+        const spaceId = getSpaceIdFromCollectionId(collectionId);
+        const authorizedDevices = this._authorizedDevices.get(spaceId);
+        if (!connection.remoteDeviceKey) {
+          log5("device key not found for collection sync check", {
+            peerId: connection.peerId,
+            collectionId
+          }, {
+            F: __dxlog_file6,
+            L: 134,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return false;
+        }
+        const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
+        return isAuthorized;
+      }
+    });
+    this._connections.add(connection);
+    return connection.replicatorExtension;
+  }
+  async authorizeDevice(spaceKey, deviceKey) {
+    log5("authorizeDevice", {
+      spaceKey,
+      deviceKey
+    }, {
+      F: __dxlog_file6,
+      L: 151,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const spaceId = await createIdFromSpaceKey(spaceKey);
+    defaultMap2(this._authorizedDevices, spaceId, () => new ComplexSet(PublicKey2.hash)).add(deviceKey);
+    for (const connection of this._connections) {
+      if (connection.remoteDeviceKey && connection.remoteDeviceKey.equals(deviceKey)) {
+        if (this._connectionsPerPeer.has(connection.peerId)) {
+          this._context?.onConnectionAuthScopeChanged(connection);
+        }
+      }
+    }
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/echo-data-monitor.ts
+import { trace as trace2 } from "@dxos/tracing";
+import { CircularBuffer, mapValues, SlidingWindowSummary } from "@dxos/util";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var PER_SECOND_RATE_AVG_WINDOW_SIZE = 5;
+var DEFAULT_AVG_WINDOW_SIZE = 25;
+var EchoDataMonitor = class {
+  constructor(_params = {
+    timeSeriesLength: 30
+  }) {
+    this._params = _params;
+    this._lastTick = 0;
+    this._activeCounters = createLocalCounters();
+    this._localTimeSeries = createLocalTimeSeries();
+    this._storageAverages = createStorageAverages();
+    this._replicationAverages = createNetworkAverages();
+    this._sizeByMessageType = {};
+    this._lastReceivedMessages = new CircularBuffer(100);
+    this._lastSentMessages = new CircularBuffer(100);
+    this._connectionsCount = 0;
+  }
+  tick(timeMs) {
+    this._advanceTimeWindow(timeMs - this._lastTick);
+    this._lastTick = timeMs;
+  }
+  computeStats() {
+    return {
+      meta: {
+        rateAverageOverSeconds: PER_SECOND_RATE_AVG_WINDOW_SIZE
+      },
+      storage: {
+        reads: {
+          payloadSize: this._storageAverages.loadedChunkSize.average(),
+          opDuration: this._storageAverages.loadDuration.average(),
+          countPerSecond: this._storageAverages.loadsPerSecond.average()
+        },
+        writes: {
+          payloadSize: this._storageAverages.storedChunkSize.average(),
+          opDuration: this._storageAverages.storeDuration.average(),
+          countPerSecond: this._storageAverages.storesPerSecond.average()
+        }
+      },
+      replicator: {
+        connections: this._connectionsCount,
+        receivedMessages: {
+          payloadSize: this._replicationAverages.receivedMessageSize.average(),
+          countPerSecond: this._replicationAverages.receivedPerSecond.average()
+        },
+        sentMessages: {
+          payloadSize: this._replicationAverages.sentMessageSize.average(),
+          opDuration: this._replicationAverages.sendDuration.average(),
+          countPerSecond: this._replicationAverages.sentPerSecond.average(),
+          failedPerSecond: this._replicationAverages.sendsFailedPerSecond.average()
+        },
+        countByMessageType: this._computeMessageHistogram("type"),
+        avgSizeByMessageType: mapValues(this._sizeByMessageType, (summary) => summary.average())
+      }
+    };
+  }
+  get connectionsCount() {
+    return this._connectionsCount;
+  }
+  /**
+  * @internal
+  */
+  get lastPerSecondStats() {
+    return this._lastCompleteCounters;
+  }
+  /**
+  * @internal
+  */
+  get timeSeries() {
+    return {
+      ...this._localTimeSeries.storage,
+      ...this._localTimeSeries.replication
+    };
+  }
+  /**
+  * @internal
+  */
+  get messagesByPeerId() {
+    return this._computeMessageHistogram("peerId");
+  }
+  _advanceTimeWindow(millisPassed) {
+    const oldMetrics = Object.freeze(this._activeCounters);
+    this._activeCounters = createLocalCounters();
+    this._lastCompleteCounters = oldMetrics;
+    for (const peerId of Object.keys(oldMetrics.byPeerId)) {
+      this._activeCounters.byPeerId[peerId] = createMessageCounter();
+    }
+    this._addToTimeSeries(oldMetrics.replication, this._localTimeSeries.replication);
+    this._addToTimeSeries(oldMetrics.storage, this._localTimeSeries.storage);
+    if (Math.abs(millisPassed - 1e3) < 100) {
+      this._reportPerSecondRate(oldMetrics);
+    }
+  }
+  _addToTimeSeries(values, timeSeries) {
+    for (const [key, value] of Object.entries(values)) {
+      const values2 = timeSeries[key];
+      values2.push(value);
+      if (values2.length > this._params.timeSeriesLength) {
+        values2.shift();
+      }
+    }
+  }
+  _reportPerSecondRate(metrics) {
+    const toReport = [
+      [
+        "storage.load",
+        metrics.storage.loadedChunks,
+        this._storageAverages.loadsPerSecond
+      ],
+      [
+        "storage.store",
+        metrics.storage.storedChunks,
+        this._storageAverages.storesPerSecond
+      ],
+      [
+        "network.receive",
+        metrics.replication.received,
+        this._replicationAverages.receivedPerSecond
+      ],
+      [
+        "network.send",
+        metrics.replication.sent,
+        this._replicationAverages.sentPerSecond
+      ]
+    ];
+    for (const [metricName, metric, summary] of toReport) {
+      summary.record(metric);
+      if (metric > 0) {
+        trace2.metrics.distribution(`dxos.echo.${metricName}-rate`, metric);
+        trace2.metrics.increment(`dxos.echo.${metricName}`, 1, {
+          tags: {
+            status: "busy"
+          }
+        });
+      } else {
+        trace2.metrics.increment(`dxos.echo.${metricName}`, 1, {
+          tags: {
+            status: "idle"
+          }
+        });
+      }
+    }
+    this._replicationAverages.sendsFailedPerSecond.record(metrics.replication.failed);
+  }
+  recordPeerConnected(peerId) {
+    this._activeCounters.byPeerId[peerId] = createMessageCounter();
+    this._connectionsCount++;
+  }
+  recordPeerDisconnected(peerId) {
+    this._connectionsCount--;
+    delete this._activeCounters.byPeerId[peerId];
+  }
+  recordBytesStored(count) {
+    this._activeCounters.storage.storedChunks++;
+    this._activeCounters.storage.storedBytes += count;
+    this._storageAverages.storedChunkSize.record(count);
+    trace2.metrics.distribution("dxos.echo.storage.bytes-stored", count, {
+      unit: "bytes"
+    });
+  }
+  recordLoadDuration(durationMs) {
+    this._storageAverages.loadDuration.record(durationMs);
+  }
+  recordStoreDuration(durationMs) {
+    this._storageAverages.storeDuration.record(durationMs);
+  }
+  recordBytesLoaded(count) {
+    this._activeCounters.storage.loadedChunks++;
+    this._activeCounters.storage.loadedBytes += count;
+    this._storageAverages.loadedChunkSize.record(count);
+    trace2.metrics.distribution("dxos.echo.storage.bytes-loaded", count, {
+      unit: "bytes"
+    });
+  }
+  recordMessageSent(message, duration) {
+    let metricsGroupName;
+    const bytes = getByteCount(message);
+    const tags = {
+      type: message.type
+    };
+    if (isAutomergeProtocolMessage(message)) {
+      this._activeCounters.replication.sent++;
+      this._replicationAverages.sendDuration.record(duration);
+      this._replicationAverages.sentMessageSize.record(bytes);
+      metricsGroupName = "replication";
+    } else {
+      metricsGroupName = "collection-sync";
+    }
+    trace2.metrics.distribution(`dxos.echo.${metricsGroupName}.bytes-sent`, bytes, {
+      unit: "bytes",
+      tags
+    });
+    trace2.metrics.distribution(`dxos.echo.${metricsGroupName}.send-duration`, duration, {
+      unit: "millisecond",
+      tags
+    });
+    trace2.metrics.increment(`dxos.echo.${metricsGroupName}.send-status`, 1, {
+      tags: {
+        ...tags,
+        success: true
+      }
+    });
+    const { messageSize, messageCounts } = this._getStatsForType(message);
+    messageSize.record(bytes);
+    messageCounts.sent++;
+    this._lastSentMessages.push({
+      type: message.type,
+      peerId: message.targetId
+    });
+  }
+  recordMessageReceived(message) {
+    const bytes = getByteCount(message);
+    const tags = {
+      type: message.type
+    };
+    if (isAutomergeProtocolMessage(message)) {
+      this._activeCounters.replication.received++;
+      this._replicationAverages.receivedMessageSize.record(bytes);
+      trace2.metrics.distribution("dxos.echo.replication.bytes-received", bytes, {
+        unit: "bytes",
+        tags
+      });
+    } else {
+      trace2.metrics.distribution("dxos.echo.collection-sync.bytes-received", bytes, {
+        unit: "bytes",
+        tags
+      });
+    }
+    const { messageSize, messageCounts } = this._getStatsForType(message);
+    messageSize.record(bytes);
+    messageCounts.received++;
+    this._lastReceivedMessages.push({
+      type: message.type,
+      peerId: message.senderId
+    });
+  }
+  recordMessageSendingFailed(message) {
+    const tags = {
+      type: message.type,
+      success: false
+    };
+    if (isAutomergeProtocolMessage(message)) {
+      this._activeCounters.replication.failed++;
+      trace2.metrics.increment("dxos.echo.replication.send-status", 1, {
+        unit: "bytes",
+        tags
+      });
+    } else {
+      trace2.metrics.increment("dxos.echo.collection-sync.send-status", 1, {
+        unit: "bytes",
+        tags
+      });
+    }
+    const { messageCounts } = this._getStatsForType(message);
+    messageCounts.failed++;
+  }
+  _getStatsForType(message) {
+    const messageSize = this._sizeByMessageType[message.type] ??= createSlidingWindow();
+    const messageCounts = this._activeCounters.byType[message.type] ??= createMessageCounter();
+    return {
+      messageCounts,
+      messageSize
+    };
+  }
+  _computeMessageHistogram(groupKey) {
+    const result = {};
+    for (const receivedMessage of this._lastReceivedMessages) {
+      const counters = result[receivedMessage[groupKey]] ??= {
+        received: 0,
+        sent: 0
+      };
+      counters.received++;
+    }
+    for (const receivedMessage of this._lastSentMessages) {
+      const counters = result[receivedMessage[groupKey]] ??= {
+        received: 0,
+        sent: 0
+      };
+      counters.sent++;
+    }
+    return result;
+  }
+};
+EchoDataMonitor = _ts_decorate3([
+  trace2.resource()
+], EchoDataMonitor);
+var isAutomergeProtocolMessage = (message) => {
+  return !(isCollectionQueryMessage(message) || isCollectionStateMessage(message));
+};
+var createSlidingWindow = (overrides) => new SlidingWindowSummary({
+  dataPoints: DEFAULT_AVG_WINDOW_SIZE,
+  precision: 2,
+  ...overrides
+});
+var createLocalCounters = () => ({
+  storage: {
+    loadedBytes: 0,
+    storedBytes: 0,
+    storedChunks: 0,
+    loadedChunks: 0
+  },
+  replication: createMessageCounter(),
+  byPeerId: {},
+  byType: {}
+});
+var createLocalTimeSeries = () => ({
+  storage: {
+    loadedBytes: [],
+    storedBytes: [],
+    storedChunks: [],
+    loadedChunks: []
+  },
+  replication: {
+    sent: [],
+    failed: [],
+    received: []
+  }
+});
+var createMessageCounter = () => ({
+  sent: 0,
+  received: 0,
+  failed: 0
+});
+var createNetworkAverages = () => ({
+  receivedMessageSize: createSlidingWindow(),
+  sentMessageSize: createSlidingWindow(),
+  sendDuration: createSlidingWindow(),
+  receivedPerSecond: createSlidingWindow({
+    dataPoints: PER_SECOND_RATE_AVG_WINDOW_SIZE
+  }),
+  sentPerSecond: createSlidingWindow({
+    dataPoints: PER_SECOND_RATE_AVG_WINDOW_SIZE
+  }),
+  sendsFailedPerSecond: createSlidingWindow({
+    dataPoints: PER_SECOND_RATE_AVG_WINDOW_SIZE
+  })
+});
+var createStorageAverages = () => ({
+  storedChunkSize: createSlidingWindow(),
+  loadedChunkSize: createSlidingWindow(),
+  loadDuration: createSlidingWindow(),
+  storeDuration: createSlidingWindow(),
+  loadsPerSecond: createSlidingWindow({
+    dataPoints: PER_SECOND_RATE_AVG_WINDOW_SIZE
+  }),
+  storesPerSecond: createSlidingWindow({
+    dataPoints: PER_SECOND_RATE_AVG_WINDOW_SIZE
+  })
+});
+var getByteCount = (message) => {
+  return message.type.length + message.senderId.length + message.targetId.length + (message.data?.byteLength ?? 0) + (message.documentId?.length ?? 0);
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/data-service.ts
+import { Stream } from "@dxos/codec-protobuf";
+import { invariant as invariant7 } from "@dxos/invariant";
+import { SpaceId as SpaceId2 } from "@dxos/keys";
+import { log as log6 } from "@dxos/log";
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/data-service.ts";
+var DataServiceImpl = class {
+  constructor(params) {
+    /**
+    * Map of subscriptions.
+    * subscriptionId -> DocumentsSynchronizer
+    */
+    this._subscriptions = /* @__PURE__ */ new Map();
+    this._automergeHost = params.automergeHost;
+    this._updateIndexes = params.updateIndexes;
+  }
+  subscribe(request) {
+    return new Stream(({ next, ready }) => {
+      const synchronizer = new DocumentsSynchronizer({
+        repo: this._automergeHost.repo,
+        sendUpdates: (updates) => next(updates)
+      });
+      synchronizer.open().then(() => {
+        this._subscriptions.set(request.subscriptionId, synchronizer);
+        ready();
+      }).catch((err) => log6.catch(err, void 0, {
+        F: __dxlog_file7,
+        L: 64,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+      return () => synchronizer.close();
+    });
+  }
+  async updateSubscription(request) {
+    const synchronizer = this._subscriptions.get(request.subscriptionId);
+    invariant7(synchronizer, "Subscription not found", {
+      F: __dxlog_file7,
+      L: 71,
+      S: this,
+      A: [
+        "synchronizer",
+        "'Subscription not found'"
+      ]
+    });
+    if (request.addIds?.length) {
+      await synchronizer.addDocuments(request.addIds);
+    }
+    if (request.removeIds?.length) {
+      await synchronizer.removeDocuments(request.removeIds);
+    }
+  }
+  async update(request) {
+    if (!request.updates) {
+      return;
+    }
+    const synchronizer = this._subscriptions.get(request.subscriptionId);
+    invariant7(synchronizer, "Subscription not found", {
+      F: __dxlog_file7,
+      L: 86,
+      S: this,
+      A: [
+        "synchronizer",
+        "'Subscription not found'"
+      ]
+    });
+    synchronizer.update(request.updates);
+  }
+  async flush(request) {
+    await this._automergeHost.flush(request);
+  }
+  async getDocumentHeads(request) {
+    const documentIds = request.documentIds;
+    if (!documentIds) {
+      return {
+        heads: {
+          entries: []
+        }
+      };
+    }
+    const heads = await this._automergeHost.getHeads(documentIds);
+    return {
+      heads: {
+        entries: heads.map((heads2, idx) => ({
+          documentId: documentIds[idx],
+          heads: heads2
+        }))
+      }
+    };
+  }
+  async waitUntilHeadsReplicated(request, options) {
+    await this._automergeHost.waitUntilHeadsReplicated(request.heads);
+  }
+  async reIndexHeads(request, options) {
+    await this._automergeHost.reIndexHeads(request.documentIds ?? []);
+  }
+  async updateIndexes() {
+    await this._updateIndexes();
+  }
+  async getSpaceSyncState(request, options) {
+    invariant7(SpaceId2.isValid(request.spaceId), void 0, {
+      F: __dxlog_file7,
+      L: 127,
+      S: this,
+      A: [
+        "SpaceId.isValid(request.spaceId)",
+        ""
+      ]
+    });
+    const collectionId = deriveCollectionIdFromSpaceId(request.spaceId);
+    const state = await this._automergeHost.getCollectionSyncState(collectionId);
+    return {
+      peers: state.peers.map((peer) => ({
+        peerId: peer.peerId,
+        documentsToReconcile: peer.differentDocuments
+      }))
+    };
+  }
+};
+
+export {
+  DocumentsSynchronizer,
+  diffCollectionState,
+  LevelDBStorageAdapter,
+  encodingOptions,
+  AutomergeHost,
+  getSpaceKeyFromDoc,
+  deriveCollectionIdFromSpaceId,
+  getSpaceIdFromCollectionId,
+  MeshEchoReplicator,
+  EchoDataMonitor,
+  DataServiceImpl
+};
+//# sourceMappingURL=chunk-Q4B5JN6L.mjs.map