@dxos/echo-pipeline 0.6.12 → 0.6.13-main.548ca8d

package/dist/lib/browser/index.mjs

@@ -1,20 +1,8 @@
 import "@dxos/node-std/globals";
-import {
-  AutomergeHost,
-  DataServiceImpl,
-  DocumentsSynchronizer,
-  EchoDataMonitor,
-  LevelDBStorageAdapter,
-  MeshEchoReplicator,
-  deriveCollectionIdFromSpaceId,
-  diffCollectionState,
-  encodingOptions,
-  getSpaceIdFromCollectionId,
-  getSpaceKeyFromDoc
-} from "./chunk-MPWFDDQK.mjs";
 import {
   AuthExtension,
   AuthStatus,
+  Buffer,
   CredentialRetrieverExtension,
   CredentialServerExtension,
   MOCK_AUTH_PROVIDER,
@@ -27,16 +15,3466 @@ import {
   SpaceProtocolSession,
   TimeframeClock,
   codec,
+  createIdFromSpaceKey,
   createMappedFeedWriter,
   hasInvitationExpired,
   mapFeedIndexesToTimeframe,
   mapTimeframeToFeedIndexes,
   startAfter,
   valueEncoding
-} from "./chunk-UKXIJW43.mjs";
-import {
-  createIdFromSpaceKey
-} from "./chunk-XPCF2V5U.mjs";
+} from "./chunk-PESZVYAN.mjs";
+
+// packages/core/echo/echo-pipeline/src/db-host/data-service.ts
+import { UpdateScheduler as UpdateScheduler2 } from "@dxos/async";
+import { Stream } from "@dxos/codec-protobuf/stream";
+import { invariant as invariant7 } from "@dxos/invariant";
+import { SpaceId as SpaceId2 } from "@dxos/keys";
+import { log as log7 } from "@dxos/log";
+
+// 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/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 log4 } from "@dxos/log";
+import { objectPointerCodec } from "@dxos/protocols";
+import { trace } from "@dxos/tracing";
+
+// 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 { log as log2 } from "@dxos/log";
+import { defaultMap } from "@dxos/util";
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/collection-synchronizer.ts";
+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) {
+    log2("setLocalCollectionState", {
+      collectionId,
+      state
+    }, {
+      F: __dxlog_file2,
+      L: 68,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    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) {
+    log2("onRemoteStateReceived", {
+      collectionId,
+      peerId,
+      state
+    }, {
+      F: __dxlog_file2,
+      L: 148,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    validateCollectionState(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 missingOnRemote = [];
+  const missingOnLocal = [];
+  const different = [];
+  for (const documentId of allDocuments) {
+    if (!local.documents[documentId]) {
+      missingOnLocal.push(documentId);
+    } else if (!remote.documents[documentId]) {
+      missingOnRemote.push(documentId);
+    } else if (!am.equals(local.documents[documentId], remote.documents[documentId])) {
+      different.push(documentId);
+    }
+  }
+  return {
+    missingOnRemote,
+    missingOnLocal,
+    different
+  };
+};
+var validateCollectionState = (state) => {
+  Object.entries(state.documents).forEach(([documentId, heads]) => {
+    if (!isValidDocumentId(documentId)) {
+      throw new Error(`Invalid documentId: ${documentId}`);
+    }
+    if (Array.isArray(heads) && heads.some((head) => typeof head !== "string")) {
+      throw new Error(`Invalid heads: ${heads}`);
+    }
+  });
+};
+var isValidDocumentId = (documentId) => {
+  return typeof documentId === "string" && !documentId.includes(":");
+};
+
+// 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 } from "@dxos/context";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log as log3 } 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_file3 = "/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 = LifecycleState.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 === LifecycleState.OPEN) {
+      return;
+    }
+    this._lifecycleState = LifecycleState.OPEN;
+    log3("emit ready", void 0, {
+      F: __dxlog_file3,
+      L: 82,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.emit("ready", {
+      network: this
+    });
+  }
+  async close() {
+    if (this._lifecycleState === LifecycleState.CLOSED) {
+      return this;
+    }
+    for (const replicator of this._replicators) {
+      await replicator.disconnect();
+    }
+    this._replicators.clear();
+    this._lifecycleState = LifecycleState.CLOSED;
+  }
+  async whenConnected() {
+    await this._connected.wait({
+      timeout: 1e4
+    });
+  }
+  async addReplicator(replicator) {
+    invariant2(this._lifecycleState === LifecycleState.OPEN, void 0, {
+      F: __dxlog_file3,
+      L: 108,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    invariant2(this.peerId, void 0, {
+      F: __dxlog_file3,
+      L: 109,
+      S: this,
+      A: [
+        "this.peerId",
+        ""
+      ]
+    });
+    invariant2(!this._replicators.has(replicator), void 0, {
+      F: __dxlog_file3,
+      L: 110,
+      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 === LifecycleState.OPEN, void 0, {
+      F: __dxlog_file3,
+      L: 129,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    invariant2(this._replicators.has(replicator), void 0, {
+      F: __dxlog_file3,
+      L: 130,
+      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) {
+        log3.catch(err, void 0, {
+          F: __dxlog_file3,
+          L: 190,
+          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) {
+    log3("Connection opened", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 208,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    invariant2(!this._connections.has(connection.peerId), void 0, {
+      F: __dxlog_file3,
+      L: 209,
+      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) {
+          log3.catch(err, void 0, {
+            F: __dxlog_file3,
+            L: 228,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    log3("emit peer-candidate", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 233,
+      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) {
+    log3("Connection auth scope changed", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 254,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const entry = this._connections.get(connection.peerId);
+    invariant2(entry, void 0, {
+      F: __dxlog_file3,
+      L: 256,
+      S: this,
+      A: [
+        "entry",
+        ""
+      ]
+    });
+    this.emit("peer-disconnected", {
+      peerId: connection.peerId
+    });
+    this._emitPeerCandidate(connection);
+  }
+  _onConnectionClosed(connection) {
+    log3("Connection closed", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 262,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const entry = this._connections.get(connection.peerId);
+    invariant2(entry, void 0, {
+      F: __dxlog_file3,
+      L: 264,
+      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) => log3.catch(err, void 0, {
+      F: __dxlog_file3,
+      L: 270,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+    void entry.writer.abort().catch((err) => log3.catch(err, void 0, {
+      F: __dxlog_file3,
+      L: 271,
+      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/leveldb-storage-adapter.ts
+import { LifecycleState as LifecycleState2, Resource as Resource3 } from "@dxos/context";
+var LevelDBStorageAdapter = class extends Resource3 {
+  constructor(_params) {
+    super();
+    this._params = _params;
+  }
+  async load(keyArray) {
+    try {
+      if (this._lifecycleState !== LifecycleState2.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 !== LifecycleState2.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 !== LifecycleState2.OPEN) {
+      return void 0;
+    }
+    await this._params.db.del(keyArray, {
+      ...encodingOptions
+    });
+  }
+  async loadRange(keyPrefix) {
+    if (this._lifecycleState !== LifecycleState2.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 !== LifecycleState2.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
+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_file4 = "/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.collectionStateUpdated = new Event2();
+    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);
+      this.collectionStateUpdated.emit({
+        collectionId
+      });
+    });
+    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_file4,
+          L: 230
+        }), 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) {
+      log4.info("re-indexing heads for document", {
+        documentId
+      }, {
+        F: __dxlog_file4,
+        L: 242,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const handle = this._repo.find(documentId);
+      await handle.whenReady([
+        "ready",
+        "requesting"
+      ]);
+      if (handle.inState([
+        "requesting"
+      ])) {
+        log4.warn("document is not available locally, skipping", {
+          documentId
+        }, {
+          F: __dxlog_file4,
+          L: 246,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const doc = handle.docSync();
+      invariant3(doc, void 0, {
+        F: __dxlog_file4,
+        L: 251,
+        S: this,
+        A: [
+          "doc",
+          ""
+        ]
+      });
+      const heads = getHeads(doc);
+      const batch = this._db.batch();
+      this._headsStore.setHeads(documentId, heads, batch);
+      await batch.write();
+    }
+    log4.info("done re-indexing heads", void 0, {
+      F: __dxlog_file4,
+      L: 258,
+      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 } = {}) {
+    const loadedDocuments = documentIds?.filter((documentId) => !!this._repo.handles[documentId]);
+    await this._repo.flush(loadedDocuments);
+  }
+  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,
+        missingOnRemote: diff.missingOnRemote.length,
+        missingOnLocal: diff.missingOnLocal.length,
+        differentDocuments: diff.different.length,
+        localDocumentCount: Object.keys(localState.documents).length,
+        remoteDocumentCount: Object.keys(state.documents).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, missingOnLocal, missingOnRemote } = diffCollectionState(localState, remoteState);
+    const toReplicate = [
+      ...missingOnLocal,
+      ...missingOnRemote,
+      ...different
+    ];
+    if (toReplicate.length === 0) {
+      return;
+    }
+    log4.info("replication documents after collection sync", {
+      count: toReplicate.length
+    }, {
+      F: __dxlog_file4,
+      L: 486,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    for (const documentId of toReplicate) {
+      this._repo.find(documentId);
+    }
+  }
+  _onHeadsChanged(documentId, heads) {
+    const collectionsChanged = /* @__PURE__ */ new Set();
+    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);
+        collectionsChanged.add(collectionId);
+      }
+    }
+    for (const collectionId of collectionsChanged) {
+      this.collectionStateUpdated.emit({
+        collectionId
+      });
+    }
+  }
+};
+_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_file4,
+    L: 544,
+    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/mesh-echo-replicator.ts
+import { invariant as invariant6 } from "@dxos/invariant";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log6 } 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 invariant4 } from "@dxos/invariant";
+import { log as log5 } 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) => {
+        invariant4(this._isEnabled, "Writing to a disabled connection", {
+          F: __dxlog_file5,
+          L: 50,
+          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;
+          log5("onStartReplication", {
+            id: info.id,
+            thisPeerId: this.peerId,
+            remotePeerId: remotePeerId.toHex()
+          }, {
+            F: __dxlog_file5,
+            L: 85,
+            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() {
+    invariant4(this._remotePeerId != null, "Remote peer has not connected yet.", {
+      F: __dxlog_file5,
+      L: 111,
+      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() {
+    invariant4(this._remotePeerId != null, "Remote peer has not connected yet.", {
+      F: __dxlog_file5,
+      L: 128,
+      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) => {
+  log5("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: 141,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/space-collection.ts
+import { invariant as invariant5 } from "@dxos/invariant";
+import { SpaceId } from "@dxos/keys";
+var __dxlog_file6 = "/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:/, "");
+  invariant5(SpaceId.isValid(spaceId), void 0, {
+    F: __dxlog_file6,
+    L: 13,
+    S: void 0,
+    A: [
+      "SpaceId.isValid(spaceId)",
+      ""
+    ]
+  });
+  return spaceId;
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts
+var __dxlog_file7 = "/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_file7,
+      L: 57,
+      S: this,
+      A: [
+        "this._context",
+        ""
+      ]
+    });
+    const connection = new MeshReplicatorConnection({
+      ownPeerId: this._context.peerId,
+      replicatorFactory: extensionFactory,
+      onRemoteConnected: async () => {
+        log6("onRemoteConnected", {
+          peerId: connection.peerId
+        }, {
+          F: __dxlog_file7,
+          L: 63,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        invariant6(this._context, void 0, {
+          F: __dxlog_file7,
+          L: 64,
+          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 () => {
+        log6("onRemoteDisconnected", {
+          peerId: connection.peerId
+        }, {
+          F: __dxlog_file7,
+          L: 75,
+          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) => {
+        log6("shouldAdvertise", {
+          peerId: connection.peerId,
+          documentId: params.documentId
+        }, {
+          F: __dxlog_file7,
+          L: 82,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        invariant6(this._context, void 0, {
+          F: __dxlog_file7,
+          L: 83,
+          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
+            });
+            log6("document not found locally for share policy check, accepting the remote document", {
+              peerId: connection.peerId,
+              documentId: params.documentId,
+              remoteDocumentExists
+            }, {
+              F: __dxlog_file7,
+              L: 91,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return remoteDocumentExists;
+          }
+          const spaceId = await createIdFromSpaceKey(spaceKey);
+          const authorizedDevices = this._authorizedDevices.get(spaceId);
+          if (!connection.remoteDeviceKey) {
+            log6("device key not found for share policy check", {
+              peerId: connection.peerId,
+              documentId: params.documentId
+            }, {
+              F: __dxlog_file7,
+              L: 107,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return false;
+          }
+          const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
+          log6("share policy check", {
+            localPeer: this._context.peerId,
+            remotePeer: connection.peerId,
+            documentId: params.documentId,
+            deviceKey: connection.remoteDeviceKey,
+            spaceKey,
+            isAuthorized
+          }, {
+            F: __dxlog_file7,
+            L: 115,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return isAuthorized;
+        } catch (err) {
+          log6.catch(err, void 0, {
+            F: __dxlog_file7,
+            L: 125,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return false;
+        }
+      },
+      shouldSyncCollection: ({ collectionId }) => {
+        const spaceId = getSpaceIdFromCollectionId(collectionId);
+        const authorizedDevices = this._authorizedDevices.get(spaceId);
+        if (!connection.remoteDeviceKey) {
+          log6("device key not found for collection sync check", {
+            peerId: connection.peerId,
+            collectionId
+          }, {
+            F: __dxlog_file7,
+            L: 135,
+            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) {
+    log6("authorizeDevice", {
+      spaceKey,
+      deviceKey
+    }, {
+      F: __dxlog_file7,
+      L: 152,
+      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
+var __dxlog_file8 = "/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) => log7.catch(err, void 0, {
+        F: __dxlog_file8,
+        L: 66,
+        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_file8,
+      L: 73,
+      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_file8,
+      L: 88,
+      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();
+  }
+  subscribeSpaceSyncState(request) {
+    return new Stream(({ ctx, next, ready }) => {
+      invariant7(SpaceId2.isValid(request.spaceId), void 0, {
+        F: __dxlog_file8,
+        L: 127,
+        S: this,
+        A: [
+          "SpaceId.isValid(request.spaceId)",
+          ""
+        ]
+      });
+      const collectionId = deriveCollectionIdFromSpaceId(request.spaceId);
+      const scheduler = new UpdateScheduler2(ctx, async () => {
+        const state = await this._automergeHost.getCollectionSyncState(collectionId);
+        next({
+          peers: state.peers.map((peer) => ({
+            peerId: peer.peerId,
+            missingOnRemote: peer.missingOnRemote,
+            missingOnLocal: peer.missingOnLocal,
+            differentDocuments: peer.differentDocuments,
+            localDocumentCount: peer.localDocumentCount,
+            remoteDocumentCount: peer.remoteDocumentCount
+          }))
+        });
+      });
+      this._automergeHost.collectionStateUpdated.on(ctx, (e) => {
+        if (e.collectionId === collectionId) {
+          scheduler.trigger();
+        }
+      });
+      scheduler.trigger();
+    });
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/echo-host.ts
+import { LifecycleState as LifecycleState4, Resource as Resource9 } from "@dxos/context";
+import { todo } from "@dxos/debug";
+import { createIdFromSpaceKey as createIdFromSpaceKey3, SpaceDocVersion as SpaceDocVersion3 } from "@dxos/echo-protocol";
+import { IndexMetadataStore, IndexStore, Indexer } from "@dxos/indexing";
+import { invariant as invariant11 } from "@dxos/invariant";
+import { IndexKind } from "@dxos/protocols/proto/dxos/echo/indexing";
+import { trace as trace5 } from "@dxos/tracing";
+
+// packages/core/echo/echo-pipeline/src/db-host/documents-iterator.ts
+import * as A3 from "@dxos/automerge/automerge";
+import { Context as Context2 } from "@dxos/context";
+import { SpaceDocVersion } from "@dxos/echo-protocol";
+import { invariant as invariant8 } from "@dxos/invariant";
+import { log as log8 } from "@dxos/log";
+import { ObjectPointerVersion, objectPointerCodec as objectPointerCodec2 } from "@dxos/protocols";
+var __dxlog_file9 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/documents-iterator.ts";
+var LOG_VIEW_OPERATION_THRESHOLD = 300;
+var createSelectedDocumentsIterator = (automergeHost) => (
+  /**
+  * Get object data blobs from Automerge Repo by ids.
+  */
+  // TODO(mykola): Unload automerge handles after usage.
+  async function* loadDocuments(objects) {
+    for (const [id, heads] of objects.entries()) {
+      try {
+        const { documentId, objectId } = objectPointerCodec2.decode(id);
+        const handle = await automergeHost.loadDoc(Context2.default(void 0, {
+          F: __dxlog_file9,
+          L: 30
+        }), documentId);
+        let doc = handle.docSync();
+        invariant8(doc, void 0, {
+          F: __dxlog_file9,
+          L: 33,
+          S: this,
+          A: [
+            "doc",
+            ""
+          ]
+        });
+        const currentHeads = A3.getHeads(doc);
+        if (!A3.equals(currentHeads, heads)) {
+          const begin = Date.now();
+          doc = A3.view(doc, heads);
+          const end = Date.now();
+          if (end - begin > LOG_VIEW_OPERATION_THRESHOLD) {
+            log8.info("Checking out document version is taking too long", {
+              duration: end - begin,
+              requestedHeads: heads,
+              originalHeads: currentHeads
+            }, {
+              F: __dxlog_file9,
+              L: 44,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+        }
+        if (doc.version !== SpaceDocVersion.CURRENT) {
+          continue;
+        }
+        if (!doc.objects?.[objectId]) {
+          continue;
+        }
+        let newId = id;
+        if (objectPointerCodec2.getVersion(id) === ObjectPointerVersion.V0) {
+          const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+          newId = objectPointerCodec2.encode({
+            documentId,
+            objectId,
+            spaceKey
+          });
+        }
+        yield [
+          {
+            id: newId,
+            object: doc.objects[objectId],
+            heads
+          }
+        ];
+      } catch (error) {
+        log8.error("Error loading document", {
+          heads,
+          id,
+          error
+        }, {
+          F: __dxlog_file9,
+          L: 70,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+  }
+);
+
+// packages/core/echo/echo-pipeline/src/db-host/query-service.ts
+import { DeferredTask } from "@dxos/async";
+import { getHeads as getHeads3 } from "@dxos/automerge/automerge";
+import { Stream as Stream2 } from "@dxos/codec-protobuf";
+import { Context as Context4, Resource as Resource7 } from "@dxos/context";
+import { log as log9 } from "@dxos/log";
+import { objectPointerCodec as objectPointerCodec4 } from "@dxos/protocols";
+import { trace as trace4 } from "@dxos/tracing";
+
+// packages/core/echo/echo-pipeline/src/db-host/query-state.ts
+import { Context as Context3, LifecycleState as LifecycleState3, Resource as Resource6 } from "@dxos/context";
+import { createIdFromSpaceKey as createIdFromSpaceKey2 } from "@dxos/echo-protocol";
+import { invariant as invariant9 } from "@dxos/invariant";
+import { PublicKey as PublicKey3 } from "@dxos/keys";
+import { objectPointerCodec as objectPointerCodec3 } from "@dxos/protocols";
+import { trace as trace3 } from "@dxos/tracing";
+import { nonNullable as nonNullable2 } from "@dxos/util";
+function _ts_decorate4(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_file10 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/query-state.ts";
+var QueryState = class extends Resource6 {
+  get active() {
+    return this._lifecycleState === LifecycleState3.OPEN;
+  }
+  constructor(_params) {
+    super();
+    this._params = _params;
+    this._results = [];
+    this._firstRun = true;
+    this.metrics = {
+      objectsReturned: 0,
+      objectsReturnedFromIndex: 0,
+      documentsLoaded: 0,
+      executionTime: 0,
+      indexQueryTime: 0,
+      documentLoadTime: 0
+    };
+    this.filter = _params.request.filter;
+  }
+  getResults() {
+    return this._results;
+  }
+  // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/attributes-registry/db.md#generic-database-attributes
+  async execQuery() {
+    const filter = this._params.request.filter;
+    const beginQuery = performance.now();
+    const hits = filter.objectIds && filter.objectIds?.length > 0 ? [] : await this._params.indexer.execQuery(filterToIndexQuery(filter));
+    if (this._firstRun) {
+      this.metrics.indexQueryTime = performance.now() - beginQuery;
+    }
+    const beginFilter = performance.now();
+    const results = (await Promise.all(hits.map(async (result) => {
+      if (this._firstRun) {
+        this.metrics.objectsReturnedFromIndex++;
+      }
+      const { objectId, documentId, spaceKey: spaceKeyInIndex } = objectPointerCodec3.decode(result.id);
+      let spaceKey;
+      if (spaceKeyInIndex !== void 0) {
+        spaceKey = spaceKeyInIndex;
+      } else {
+        if (this._firstRun) {
+          this.metrics.documentsLoaded++;
+        }
+        const handle = await this._params.automergeHost.loadDoc(Context3.default(void 0, {
+          F: __dxlog_file10,
+          L: 116
+        }), documentId);
+        if (this._ctx.disposed) {
+          return;
+        }
+        spaceKey = getSpaceKeyFromDoc(handle.docSync());
+      }
+      if (!spaceKey) {
+        return;
+      }
+      if (this._params.request.filter.options?.spaces?.length && !this._params.request.filter.options.spaces.some((key) => key.equals(spaceKey))) {
+        return;
+      }
+      if (this._firstRun) {
+        this.metrics.objectsReturned++;
+      }
+      return {
+        id: objectId,
+        documentId,
+        spaceId: await createIdFromSpaceKey2(PublicKey3.from(spaceKey)),
+        spaceKey: PublicKey3.from(spaceKey),
+        rank: result.rank
+      };
+    }))).filter(nonNullable2);
+    if (this._firstRun) {
+      this.metrics.documentLoadTime = performance.now() - beginFilter;
+    }
+    if (this._ctx.disposed) {
+      return {
+        changed: false
+      };
+    }
+    const areResultsUnchanged = !this._firstRun && this._results.length === results.length && this._results.every((oldResult) => results.some((result) => result.id === oldResult.id)) && results.every((result) => this._results.some((oldResult) => oldResult.id === result.id));
+    if (this._firstRun) {
+      this.metrics.executionTime = performance.now() - beginQuery;
+    }
+    this._firstRun = false;
+    if (areResultsUnchanged) {
+      return {
+        changed: false
+      };
+    }
+    this._results = results;
+    return {
+      changed: true
+    };
+  }
+};
+_ts_decorate4([
+  trace3.info({
+    depth: null
+  })
+], QueryState.prototype, "filter", void 0);
+_ts_decorate4([
+  trace3.info()
+], QueryState.prototype, "metrics", void 0);
+_ts_decorate4([
+  trace3.info()
+], QueryState.prototype, "active", null);
+_ts_decorate4([
+  trace3.span({
+    showInBrowserTimeline: true,
+    op: "db.query",
+    attributes: {
+      "db.system": "echo"
+    }
+  })
+], QueryState.prototype, "execQuery", null);
+QueryState = _ts_decorate4([
+  trace3.resource()
+], QueryState);
+var filterToIndexQuery = (filter) => {
+  invariant9(!(filter.type && (filter.or ?? []).length > 0), "Cannot mix type and or filters.", {
+    F: __dxlog_file10,
+    L: 181,
+    S: void 0,
+    A: [
+      "!(filter.type && (filter.or ?? []).length > 0)",
+      "'Cannot mix type and or filters.'"
+    ]
+  });
+  invariant9((filter.or ?? []).every((subFilter) => !(subFilter.type && (subFilter.or ?? []).length > 0)), "Cannot mix type and or filters.", {
+    F: __dxlog_file10,
+    L: 182,
+    S: void 0,
+    A: [
+      "(filter.or ?? []).every((subFilter) => !(subFilter.type && (subFilter.or ?? []).length > 0))",
+      "'Cannot mix type and or filters.'"
+    ]
+  });
+  if (filter.type || (filter.or ?? []).length > 0 && (filter.or ?? []).every((subFilter) => !subFilter.not && subFilter.type)) {
+    return {
+      typenames: filter.type?.objectId ? [
+        filter.type.objectId
+      ] : (filter.or ?? []).map((f) => f.type?.objectId).filter(nonNullable2),
+      inverted: filter.not
+    };
+  } else {
+    return {
+      typenames: []
+    };
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/query-service.ts
+var __dxlog_file11 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/query-service.ts";
+var QueryServiceImpl = class extends Resource7 {
+  // TODO(burdon): OK for options, but not params. Pass separately and type readonly here.
+  constructor(_params) {
+    super();
+    this._params = _params;
+    this._queries = /* @__PURE__ */ new Set();
+    this._updateQueries = new DeferredTask(this._ctx, async () => {
+      await Promise.all(Array.from(this._queries).map(async (query) => {
+        try {
+          const { changed } = await query.state.execQuery();
+          if (changed) {
+            query.sendResults(query.state.getResults());
+          }
+        } catch (err) {
+          log9.catch(err, void 0, {
+            F: __dxlog_file11,
+            L: 52,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      }));
+    });
+    trace4.diagnostic({
+      id: "active-queries",
+      name: "Active Queries",
+      fetch: () => {
+        return Array.from(this._queries).map((query) => {
+          return {
+            filter: JSON.stringify(query.state.filter),
+            metrics: query.state.metrics
+          };
+        });
+      }
+    });
+  }
+  async _open() {
+    this._params.indexer.updated.on(this._ctx, () => this._updateQueries.schedule());
+  }
+  async _close() {
+    await Promise.all(Array.from(this._queries).map((query) => query.close()));
+  }
+  async setConfig(config) {
+    if (this._params.indexer.initialized) {
+      log9.warn("Indexer already initialized.", void 0, {
+        F: __dxlog_file11,
+        L: 86,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    this._params.indexer.setConfig(config);
+  }
+  execQuery(request) {
+    return new Stream2(({ next, close, ctx }) => {
+      const query = {
+        state: new QueryState({
+          indexer: this._params.indexer,
+          automergeHost: this._params.automergeHost,
+          request
+        }),
+        sendResults: (results) => {
+          if (ctx.disposed) {
+            return;
+          }
+          next({
+            queryId: request.queryId,
+            results
+          });
+        },
+        close: async () => {
+          close();
+          await query.state.close();
+          this._queries.delete(query);
+        }
+      };
+      this._queries.add(query);
+      queueMicrotask(async () => {
+        await query.state.open();
+        try {
+          const { changed } = await query.state.execQuery();
+          if (changed) {
+            query.sendResults(query.state.getResults());
+          }
+        } catch (error) {
+          log9.catch(error, void 0, {
+            F: __dxlog_file11,
+            L: 123,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      });
+      return query.close;
+    });
+  }
+  /**
+  * Re-index all loaded documents.
+  */
+  async reindex() {
+    log9.info("Reindexing all documents...", void 0, {
+      F: __dxlog_file11,
+      L: 135,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const iterator = createDocumentsIterator(this._params.automergeHost);
+    const ids = /* @__PURE__ */ new Map();
+    for await (const documents of iterator()) {
+      for (const { id, heads } of documents) {
+        ids.set(id, heads);
+      }
+      if (ids.size % 100 === 0) {
+        log9.info("Collected documents...", {
+          count: ids.size
+        }, {
+          F: __dxlog_file11,
+          L: 143,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+    log9.info("Marking all documents as dirty...", {
+      count: ids.size
+    }, {
+      F: __dxlog_file11,
+      L: 147,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._params.indexer.reindex(ids);
+  }
+};
+var createDocumentsIterator = (automergeHost) => (
+  /**
+  * Recursively get all object data blobs from loaded documents from Automerge Repo.
+  */
+  // TODO(mykola): Unload automerge handles after usage.
+  async function* getAllDocuments() {
+    const visited = /* @__PURE__ */ new Set();
+    async function* getObjectsFromHandle(handle) {
+      if (visited.has(handle.documentId)) {
+        return;
+      }
+      const doc = handle.docSync();
+      const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+      if (doc.objects) {
+        yield Object.entries(doc.objects).map(([objectId, object]) => {
+          return {
+            id: objectPointerCodec4.encode({
+              documentId: handle.documentId,
+              objectId,
+              spaceKey
+            }),
+            object,
+            heads: getHeads3(doc)
+          };
+        });
+      }
+      if (doc.links) {
+        for (const id of Object.values(doc.links)) {
+          if (visited.has(id)) {
+            continue;
+          }
+          const linkHandle = await automergeHost.loadDoc(Context4.default(void 0, {
+            F: __dxlog_file11,
+            L: 188
+          }), id);
+          for await (const result of getObjectsFromHandle(linkHandle)) {
+            yield result;
+          }
+        }
+      }
+      visited.add(handle.documentId);
+    }
+    for (const handle of Object.values(automergeHost.repo.handles)) {
+      if (visited.has(handle.documentId)) {
+        continue;
+      }
+      for await (const result of getObjectsFromHandle(handle)) {
+        yield result;
+      }
+      visited.add(handle.documentId);
+    }
+  }
+);
+
+// packages/core/echo/echo-pipeline/src/db-host/space-state-manager.ts
+import isEqual from "lodash.isequal";
+import { Event as Event3, UpdateScheduler as UpdateScheduler3 } from "@dxos/async";
+import { interpretAsDocumentId } from "@dxos/automerge/automerge-repo";
+import { Resource as Resource8, Context as Context5 } from "@dxos/context";
+
+// packages/core/echo/echo-pipeline/src/db-host/database-root.ts
+import { SpaceDocVersion as SpaceDocVersion2 } from "@dxos/echo-protocol";
+import { invariant as invariant10 } from "@dxos/invariant";
+
+// packages/core/echo/echo-pipeline/src/db-host/automerge-metrics.ts
+import * as A4 from "@dxos/automerge/automerge";
+import { log as log10 } from "@dxos/log";
+var __dxlog_file12 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/automerge-metrics.ts";
+var measureDocMetrics = (doc) => {
+  const snapshot = A4.save(doc);
+  const start = Date.now();
+  const temp = A4.load(snapshot);
+  const end = Date.now();
+  A4.free(temp);
+  const getAllChangesStart = Date.now();
+  const mutationCount = A4.getAllChanges(doc).length;
+  const getAllChangesEnd = Date.now();
+  if (getAllChangesEnd - getAllChangesStart > 300) {
+    log10.warn("getAllChanges took too long", {
+      elapsed: getAllChangesEnd - getAllChangesStart
+    }, {
+      F: __dxlog_file12,
+      L: 30,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  }
+  return {
+    compressedByteSize: snapshot.byteLength,
+    loadTime: end - start,
+    mutationCount
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/database-root.ts
+var __dxlog_file13 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/database-root.ts";
+var DatabaseRoot = class {
+  constructor(_rootHandle) {
+    this._rootHandle = _rootHandle;
+  }
+  get documentId() {
+    return this._rootHandle.documentId;
+  }
+  get url() {
+    return this._rootHandle.url;
+  }
+  get isLoaded() {
+    return !!this._rootHandle.docSync();
+  }
+  get handle() {
+    return this._rootHandle;
+  }
+  docSync() {
+    return this._rootHandle.docSync();
+  }
+  getVersion() {
+    const doc = this.docSync();
+    if (!doc) {
+      return null;
+    }
+    return doc.version ?? SpaceDocVersion2.LEGACY;
+  }
+  getSpaceKey() {
+    const doc = this.docSync();
+    if (!doc) {
+      return null;
+    }
+    return getSpaceKeyFromDoc(doc);
+  }
+  getInlineObjectCount() {
+    const doc = this.docSync();
+    if (!doc) {
+      return null;
+    }
+    return Object.keys(doc.objects ?? {}).length;
+  }
+  getLinkedObjectCount() {
+    const doc = this.docSync();
+    if (!doc) {
+      return null;
+    }
+    return Object.keys(doc.links ?? {}).length;
+  }
+  getAllLinkedDocuments() {
+    const doc = this.docSync();
+    invariant10(doc, void 0, {
+      F: __dxlog_file13,
+      L: 74,
+      S: this,
+      A: [
+        "doc",
+        ""
+      ]
+    });
+    return Object.values(doc.links ?? {});
+  }
+  measureMetrics() {
+    const doc = this.docSync();
+    if (!doc) {
+      return null;
+    }
+    return measureDocMetrics(doc);
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/space-state-manager.ts
+var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/space-state-manager.ts";
+var SpaceStateManager = class extends Resource8 {
+  constructor() {
+    super(...arguments);
+    this._roots = /* @__PURE__ */ new Map();
+    this._rootBySpace = /* @__PURE__ */ new Map();
+    this._perRootContext = /* @__PURE__ */ new Map();
+    this._lastSpaceDocumentList = /* @__PURE__ */ new Map();
+    this.spaceDocumentListUpdated = new Event3();
+  }
+  async _close(ctx) {
+    for (const [_, rootCtx] of this._perRootContext) {
+      await rootCtx.dispose();
+    }
+    this._roots.clear();
+  }
+  get roots() {
+    return this._roots;
+  }
+  getRootByDocumentId(documentId) {
+    return this._roots.get(documentId);
+  }
+  async assignRootToSpace(spaceId, handle) {
+    let root;
+    if (this._roots.has(handle.documentId)) {
+      root = this._roots.get(handle.documentId);
+    } else {
+      root = new DatabaseRoot(handle);
+      this._roots.set(handle.documentId, root);
+    }
+    if (this._rootBySpace.get(spaceId) === root.handle.documentId) {
+      return root;
+    }
+    const prevRootId = this._rootBySpace.get(spaceId);
+    if (prevRootId) {
+      void this._perRootContext.get(prevRootId)?.dispose();
+      this._perRootContext.delete(prevRootId);
+    }
+    this._rootBySpace.set(spaceId, root.handle.documentId);
+    const ctx = new Context5(void 0, {
+      F: __dxlog_file14,
+      L: 58
+    });
+    this._perRootContext.set(root.handle.documentId, ctx);
+    await root.handle.whenReady();
+    const documentListCheckScheduler = new UpdateScheduler3(ctx, async () => {
+      const documentIds = [
+        root.documentId,
+        ...root.getAllLinkedDocuments().map((url) => interpretAsDocumentId(url))
+      ];
+      if (!isEqual(documentIds, this._lastSpaceDocumentList.get(spaceId))) {
+        this._lastSpaceDocumentList.set(spaceId, documentIds);
+        this.spaceDocumentListUpdated.emit(new SpaceDocumentListUpdatedEvent(spaceId, documentIds));
+      }
+    }, {
+      maxFrequency: 50
+    });
+    const triggerCheckOnChange = () => documentListCheckScheduler.trigger();
+    root.handle.addListener("change", triggerCheckOnChange);
+    ctx.onDispose(() => root.handle.removeListener("change", triggerCheckOnChange));
+    documentListCheckScheduler.trigger();
+    return root;
+  }
+};
+var SpaceDocumentListUpdatedEvent = class {
+  constructor(spaceId, documentIds) {
+    this.spaceId = spaceId;
+    this.documentIds = documentIds;
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/echo-host.ts
+var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/echo-host.ts";
+var INDEXER_CONFIG = {
+  enabled: true,
+  indexes: [
+    {
+      kind: IndexKind.Kind.SCHEMA_MATCH
+    }
+  ]
+};
+var EchoHost = class extends Resource9 {
+  constructor({ kv }) {
+    super();
+    this._spaceStateManager = new SpaceStateManager();
+    this._indexMetadataStore = new IndexMetadataStore({
+      db: kv.sublevel("index-metadata")
+    });
+    this._echoDataMonitor = new EchoDataMonitor();
+    this._automergeHost = new AutomergeHost({
+      db: kv,
+      dataMonitor: this._echoDataMonitor,
+      indexMetadataStore: this._indexMetadataStore
+    });
+    this._indexer = new Indexer({
+      db: kv,
+      indexStore: new IndexStore({
+        db: kv.sublevel("index-storage")
+      }),
+      metadataStore: this._indexMetadataStore,
+      loadDocuments: createSelectedDocumentsIterator(this._automergeHost),
+      indexCooldownTime: false ? 0 : void 0
+    });
+    this._indexer.setConfig(INDEXER_CONFIG);
+    this._queryService = new QueryServiceImpl({
+      automergeHost: this._automergeHost,
+      indexer: this._indexer
+    });
+    this._dataService = new DataServiceImpl({
+      automergeHost: this._automergeHost,
+      updateIndexes: async () => {
+        await this._indexer.updateIndexes();
+      }
+    });
+    trace5.diagnostic({
+      id: "echo-stats",
+      name: "Echo Stats",
+      fetch: async () => {
+        return {
+          dataStats: this._echoDataMonitor.computeStats(),
+          loadedDocsCount: this._automergeHost.loadedDocsCount
+        };
+      }
+    });
+    trace5.diagnostic({
+      id: "database-roots",
+      name: "Database Roots",
+      fetch: async () => {
+        return Array.from(this._spaceStateManager.roots.values()).map((root) => ({
+          url: root.url,
+          isLoaded: root.isLoaded,
+          spaceKey: root.getSpaceKey(),
+          inlineObjects: root.getInlineObjectCount(),
+          linkedObjects: root.getLinkedObjectCount()
+        }));
+      }
+    });
+    trace5.diagnostic({
+      id: "database-root-metrics",
+      name: "Database Roots (with metrics)",
+      fetch: async () => {
+        return Array.from(this._spaceStateManager.roots.values()).map((root) => ({
+          url: root.url,
+          isLoaded: root.isLoaded,
+          spaceKey: root.getSpaceKey(),
+          inlineObjects: root.getInlineObjectCount(),
+          linkedObjects: root.getLinkedObjectCount(),
+          ...root.measureMetrics() ?? {}
+        }));
+      }
+    });
+  }
+  get queryService() {
+    return this._queryService;
+  }
+  get dataService() {
+    return this._dataService;
+  }
+  /**
+  * @deprecated To be abstracted away.
+  */
+  get automergeRepo() {
+    return this._automergeHost.repo;
+  }
+  get roots() {
+    return this._spaceStateManager.roots;
+  }
+  async _open(ctx) {
+    await this._automergeHost.open();
+    await this._indexer.open(ctx);
+    await this._queryService.open(ctx);
+    await this._spaceStateManager.open(ctx);
+    this._spaceStateManager.spaceDocumentListUpdated.on(this._ctx, (e) => {
+      void this._automergeHost.updateLocalCollectionState(deriveCollectionIdFromSpaceId(e.spaceId), e.documentIds);
+    });
+  }
+  async _close(ctx) {
+    await this._spaceStateManager.close();
+    await this._queryService.close(ctx);
+    await this._indexer.close(ctx);
+    await this._automergeHost.close();
+  }
+  /**
+  * Flush all pending writes to the underlying storage.
+  */
+  async flush() {
+    await this._automergeHost.repo.flush();
+  }
+  /**
+  * Perform any pending index updates.
+  */
+  async updateIndexes() {
+    await this._indexer.updateIndexes();
+  }
+  /**
+  * Loads the document handle from the repo and waits for it to be ready.
+  */
+  async loadDoc(ctx, documentId, opts) {
+    return await this._automergeHost.loadDoc(ctx, documentId, opts);
+  }
+  /**
+  * Create new persisted document.
+  */
+  createDoc(initialValue, opts) {
+    return this._automergeHost.createDoc(initialValue, opts);
+  }
+  /**
+  * Create new space root.
+  */
+  async createSpaceRoot(spaceKey) {
+    invariant11(this._lifecycleState === LifecycleState4.OPEN, void 0, {
+      F: __dxlog_file15,
+      L: 206,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    const spaceId = await createIdFromSpaceKey3(spaceKey);
+    const automergeRoot = this._automergeHost.createDoc({
+      version: SpaceDocVersion3.CURRENT,
+      access: {
+        spaceKey: spaceKey.toHex()
+      }
+    });
+    await this._automergeHost.flush({
+      documentIds: [
+        automergeRoot.documentId
+      ]
+    });
+    return await this.openSpaceRoot(spaceId, automergeRoot.url);
+  }
+  // TODO(dmaretskyi): Change to document id.
+  async openSpaceRoot(spaceId, automergeUrl) {
+    invariant11(this._lifecycleState === LifecycleState4.OPEN, void 0, {
+      F: __dxlog_file15,
+      L: 221,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    const handle = this._automergeHost.repo.find(automergeUrl);
+    return this._spaceStateManager.assignRootToSpace(spaceId, handle);
+  }
+  // TODO(dmaretskyi): Change to document id.
+  async closeSpaceRoot(automergeUrl) {
+    todo();
+  }
+  /**
+  * Install data replicator.
+  */
+  async addReplicator(replicator) {
+    await this._automergeHost.addReplicator(replicator);
+  }
+  /**
+  * Remove data replicator.
+  */
+  async removeReplicator(replicator) {
+    await this._automergeHost.removeReplicator(replicator);
+  }
+  async getSpaceSyncState(spaceId) {
+    const collectionId = deriveCollectionIdFromSpaceId(spaceId);
+    return this._automergeHost.getCollectionSyncState(collectionId);
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/migration.ts
+import { convertLegacyReference } from "@dxos/echo-protocol";
+import { decodeReference, encodeReference, isLegacyReference, LEGACY_TYPE_PROPERTIES, Reference, SpaceDocVersion as SpaceDocVersion4 } from "@dxos/echo-protocol";
+import { TYPE_PROPERTIES } from "@dxos/echo-schema";
+import { deepMapValuesAsync } from "@dxos/util";
+var convertLegacyReferences = async (doc) => {
+  const newDoc = await deepMapValuesAsync(doc, async (value, recurse) => {
+    if (isLegacyReference(value)) {
+      return convertLegacyReference(value);
+    }
+    return recurse(value);
+  });
+  newDoc.version = SpaceDocVersion4.CURRENT;
+  return newDoc;
+};
+var convertLegacySpaceRootDoc = async (root) => {
+  const newDoc = await convertLegacyReferences(root);
+  const properties = findInlineObjectOfType(newDoc, LEGACY_TYPE_PROPERTIES);
+  if (properties) {
+    const [_, obj] = properties;
+    obj.system.type = encodeReference(Reference.fromLegacyTypename(TYPE_PROPERTIES));
+  }
+  return newDoc;
+};
+var findInlineObjectOfType = (spaceDoc, typename) => {
+  for (const id in spaceDoc.objects ?? {}) {
+    const obj = spaceDoc.objects[id];
+    if (obj.system.type && decodeReference(obj.system.type).objectId === typename) {
+      return [
+        id,
+        obj
+      ];
+    }
+  }
+  return void 0;
+};
+
+// packages/core/echo/echo-pipeline/src/edge/echo-edge-replicator.ts
+import { Mutex, scheduleTask as scheduleTask2 } from "@dxos/async";
+import * as A5 from "@dxos/automerge/automerge";
+import { cbor as cbor2 } from "@dxos/automerge/automerge-repo";
+import { Context as Context6, Resource as Resource10 } from "@dxos/context";
+import { randomUUID } from "@dxos/crypto";
+import { invariant as invariant12 } from "@dxos/invariant";
+import { log as log11 } from "@dxos/log";
+import { EdgeService } from "@dxos/protocols";
+import { buf } from "@dxos/protocols/buf";
+import { MessageSchema as RouterMessageSchema } from "@dxos/protocols/buf/dxos/edge/messenger_pb";
+import { bufferToArray } from "@dxos/util";
+function _using_ctx() {
+  var _disposeSuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed) {
+    var err = new Error();
+    err.name = "SuppressedError";
+    err.suppressed = suppressed;
+    err.error = error;
+    return err;
+  }, empty = {}, stack = [];
+  function using(isAwait, value) {
+    if (value != null) {
+      if (Object(value) !== value) {
+        throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+      }
+      if (isAwait) {
+        var dispose = value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
+      }
+      if (dispose == null) {
+        dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
+      }
+      if (typeof dispose !== "function") {
+        throw new TypeError(`Property [Symbol.dispose] is not a function.`);
+      }
+      stack.push({
+        v: value,
+        d: dispose,
+        a: isAwait
+      });
+    } else if (isAwait) {
+      stack.push({
+        d: value,
+        a: isAwait
+      });
+    }
+    return value;
+  }
+  return {
+    e: empty,
+    u: using.bind(null, false),
+    a: using.bind(null, true),
+    d: function() {
+      var error = this.e;
+      function next() {
+        while (resource = stack.pop()) {
+          try {
+            var resource, disposalResult = resource.d && resource.d.call(resource.v);
+            if (resource.a) {
+              return Promise.resolve(disposalResult).then(next, err);
+            }
+          } catch (e) {
+            return err(e);
+          }
+        }
+        if (error !== empty) throw error;
+      }
+      function err(e) {
+        error = error !== empty ? new _disposeSuppressedError(error, e) : e;
+        return next();
+      }
+      return next();
+    }
+  };
+}
+var __dxlog_file16 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/edge/echo-edge-replicator.ts";
+var RESTART_DELAY = 500;
+var EchoEdgeReplicator = class {
+  constructor({ edgeConnection, disableSharePolicy }) {
+    this._mutex = new Mutex();
+    this._ctx = void 0;
+    this._context = null;
+    this._connectedSpaces = /* @__PURE__ */ new Set();
+    this._connections = /* @__PURE__ */ new Map();
+    this._sharePolicyEnabled = true;
+    this._edgeConnection = edgeConnection;
+    this._sharePolicyEnabled = !disableSharePolicy;
+  }
+  async connect(context) {
+    log11.info("connect", {
+      peerId: context.peerId,
+      connectedSpaces: this._connectedSpaces.size
+    }, {
+      F: __dxlog_file16,
+      L: 58,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._context = context;
+    this._ctx = Context6.default(void 0, {
+      F: __dxlog_file16,
+      L: 61
+    });
+    this._edgeConnection.reconnect.on(this._ctx, async () => {
+      try {
+        var _usingCtx = _using_ctx();
+        const _guard = _usingCtx.u(await this._mutex.acquire());
+        const spaces = [
+          ...this._connectedSpaces
+        ];
+        for (const connection of this._connections.values()) {
+          await connection.close();
+        }
+        this._connections.clear();
+        if (this._context !== null) {
+          for (const spaceId of spaces) {
+            await this._openConnection(spaceId);
+          }
+        }
+      } catch (_) {
+        _usingCtx.e = _;
+      } finally {
+        _usingCtx.d();
+      }
+    });
+    for (const spaceId of this._connectedSpaces) {
+      await this._openConnection(spaceId);
+    }
+  }
+  async disconnect() {
+    try {
+      var _usingCtx = _using_ctx();
+      const _guard = _usingCtx.u(await this._mutex.acquire());
+      await this._ctx?.dispose();
+      for (const connection of this._connections.values()) {
+        await connection.close();
+      }
+      this._connections.clear();
+    } catch (_) {
+      _usingCtx.e = _;
+    } finally {
+      _usingCtx.d();
+    }
+  }
+  async connectToSpace(spaceId) {
+    try {
+      var _usingCtx = _using_ctx();
+      const _guard = _usingCtx.u(await this._mutex.acquire());
+      this._connectedSpaces.add(spaceId);
+      if (this._context !== null) {
+        await this._openConnection(spaceId);
+      }
+    } catch (_) {
+      _usingCtx.e = _;
+    } finally {
+      _usingCtx.d();
+    }
+  }
+  async disconnectFromSpace(spaceId) {
+    try {
+      var _usingCtx = _using_ctx();
+      const _guard = _usingCtx.u(await this._mutex.acquire());
+      this._connectedSpaces.delete(spaceId);
+      const connection = this._connections.get(spaceId);
+      if (connection) {
+        await connection.close();
+        this._connections.delete(spaceId);
+      }
+    } catch (_) {
+      _usingCtx.e = _;
+    } finally {
+      _usingCtx.d();
+    }
+  }
+  async _openConnection(spaceId) {
+    invariant12(this._context, void 0, {
+      F: __dxlog_file16,
+      L: 117,
+      S: this,
+      A: [
+        "this._context",
+        ""
+      ]
+    });
+    invariant12(!this._connections.has(spaceId), void 0, {
+      F: __dxlog_file16,
+      L: 118,
+      S: this,
+      A: [
+        "!this._connections.has(spaceId)",
+        ""
+      ]
+    });
+    const connection = new EdgeReplicatorConnection({
+      edgeConnection: this._edgeConnection,
+      ownPeerId: this._context.peerId,
+      spaceId,
+      context: this._context,
+      sharedPolicyEnabled: this._sharePolicyEnabled,
+      onRemoteConnected: async () => {
+        this._context?.onConnectionOpen(connection);
+      },
+      onRemoteDisconnected: async () => {
+        this._context?.onConnectionClosed(connection);
+      },
+      onRestartRequested: async () => {
+        try {
+          var _usingCtx = _using_ctx();
+          const _guard = _usingCtx.u(await this._mutex.acquire());
+          const ctx = this._ctx;
+          await connection.close();
+          this._connections.delete(spaceId);
+          if (ctx?.disposed) {
+            return;
+          }
+          await this._openConnection(spaceId);
+        } catch (_) {
+          _usingCtx.e = _;
+        } finally {
+          _usingCtx.d();
+        }
+      }
+    });
+    this._connections.set(spaceId, connection);
+    await connection.open();
+  }
+};
+var EdgeReplicatorConnection = class extends Resource10 {
+  constructor({ edgeConnection, ownPeerId, spaceId, context, sharedPolicyEnabled, onRemoteConnected, onRemoteDisconnected, onRestartRequested }) {
+    super();
+    this._remotePeerId = null;
+    this._restartScheduled = false;
+    this._edgeConnection = edgeConnection;
+    this._ownPeerId = ownPeerId;
+    this._spaceId = spaceId;
+    this._context = context;
+    this._remotePeerId = `${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}-${randomUUID()}`;
+    this._targetServiceId = `${EdgeService.AUTOMERGE_REPLICATOR}:${spaceId}`;
+    this._sharedPolicyEnabled = sharedPolicyEnabled;
+    this._onRemoteConnected = onRemoteConnected;
+    this._onRemoteDisconnected = onRemoteDisconnected;
+    this._onRestartRequested = onRestartRequested;
+    this.readable = new ReadableStream({
+      start: (controller) => {
+        this._readableStreamController = controller;
+      }
+    });
+    this.writable = new WritableStream({
+      write: async (message, controller) => {
+        await this._sendMessage(message);
+      }
+    });
+  }
+  async _open(ctx) {
+    log11("open", void 0, {
+      F: __dxlog_file16,
+      L: 219,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._ctx.onDispose(this._edgeConnection.addListener((msg) => {
+      this._onMessage(msg);
+    }));
+    await this._onRemoteConnected();
+  }
+  async _close() {
+    log11("close", void 0, {
+      F: __dxlog_file16,
+      L: 231,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._readableStreamController.close();
+    await this._onRemoteDisconnected();
+  }
+  get peerId() {
+    invariant12(this._remotePeerId, "Not connected", {
+      F: __dxlog_file16,
+      L: 237,
+      S: this,
+      A: [
+        "this._remotePeerId",
+        "'Not connected'"
+      ]
+    });
+    return this._remotePeerId;
+  }
+  async shouldAdvertise(params) {
+    if (!this._sharedPolicyEnabled) {
+      return true;
+    }
+    const spaceId = await this._context.getContainingSpaceIdForDocument(params.documentId);
+    if (!spaceId) {
+      return true;
+    }
+    return spaceId === this._spaceId;
+  }
+  shouldSyncCollection(params) {
+    if (!this._sharedPolicyEnabled) {
+      return true;
+    }
+    const spaceId = getSpaceIdFromCollectionId(params.collectionId);
+    return spaceId === this._spaceId;
+  }
+  _onMessage(message) {
+    if (message.serviceId !== this._targetServiceId) {
+      return;
+    }
+    const payload = cbor2.decode(message.payload.value);
+    log11("recv", () => {
+      const decodedData = payload.type === "sync" && payload.data ? A5.decodeSyncMessage(payload.data) : payload.type === "collection-state" ? payload.state : payload;
+      return {
+        from: message.serviceId,
+        type: payload.type,
+        decodedData
+      };
+    }, {
+      F: __dxlog_file16,
+      L: 268,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    payload.senderId = this._remotePeerId;
+    this._processMessage(payload);
+  }
+  _processMessage(message) {
+    if (isForbiddenErrorMessage(message)) {
+      if (!this._restartScheduled) {
+        log11.warn("Forbidden error received, replicator will restart the connection", {
+          spaceId: this._spaceId,
+          delayMs: RESTART_DELAY,
+          remotePeerId: this._remotePeerId
+        }, {
+          F: __dxlog_file16,
+          L: 288,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._restartScheduled = true;
+        scheduleTask2(this._ctx, async () => {
+          await this._onRestartRequested();
+        }, RESTART_DELAY);
+      }
+      return;
+    }
+    this._readableStreamController.enqueue(message);
+  }
+  async _sendMessage(message) {
+    message.targetId = this._targetServiceId;
+    log11("send", {
+      type: message.type,
+      senderId: message.senderId,
+      targetId: message.targetId,
+      documentId: message.documentId
+    }, {
+      F: __dxlog_file16,
+      L: 312,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const encoded = cbor2.encode(message);
+    await this._edgeConnection.send(buf.create(RouterMessageSchema, {
+      serviceId: this._targetServiceId,
+      source: {
+        identityKey: this._edgeConnection.identityKey,
+        peerKey: this._edgeConnection.peerKey
+      },
+      payload: {
+        value: bufferToArray(encoded)
+      }
+    }));
+  }
+};
+var isForbiddenErrorMessage = (message) => message.type === "error" && message.message === "Forbidden";
 export {
   AuthExtension,
   AuthStatus,
@@ -44,25 +3482,33 @@ export {
   CredentialRetrieverExtension,
   CredentialServerExtension,
   DataServiceImpl,
+  DatabaseRoot,
   DocumentsSynchronizer,
   EchoDataMonitor,
+  EchoEdgeReplicator,
+  EchoHost,
   LevelDBStorageAdapter,
   MOCK_AUTH_PROVIDER,
   MOCK_AUTH_VERIFIER,
   MeshEchoReplicator,
   MetadataStore,
   Pipeline,
+  QueryServiceImpl,
+  QueryState,
   Space,
   SpaceManager,
   SpaceProtocol,
   SpaceProtocolSession,
   TimeframeClock,
   codec,
+  convertLegacyReferences,
+  convertLegacySpaceRootDoc,
   createIdFromSpaceKey,
   createMappedFeedWriter,
   deriveCollectionIdFromSpaceId,
   diffCollectionState,
   encodingOptions,
+  findInlineObjectOfType,
   getSpaceIdFromCollectionId,
   getSpaceKeyFromDoc,
   hasInvitationExpired,