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

package/dist/lib/node/chunk-5DH4KR2S.cjs

@@ -1,2148 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_5DH4KR2S_exports = {};
-__export(chunk_5DH4KR2S_exports, {
-  AutomergeHost: () => AutomergeHost,
-  DataServiceImpl: () => DataServiceImpl,
-  DocumentsSynchronizer: () => DocumentsSynchronizer,
-  EchoDataMonitor: () => EchoDataMonitor,
-  LevelDBStorageAdapter: () => LevelDBStorageAdapter,
-  MeshEchoReplicator: () => MeshEchoReplicator,
-  deriveCollectionIdFromSpaceId: () => deriveCollectionIdFromSpaceId,
-  diffCollectionState: () => diffCollectionState,
-  encodingOptions: () => encodingOptions,
-  getSpaceIdFromCollectionId: () => getSpaceIdFromCollectionId,
-  getSpaceKeyFromDoc: () => getSpaceKeyFromDoc
-});
-module.exports = __toCommonJS(chunk_5DH4KR2S_exports);
-var import_chunk_DZVH7HDD = require("./chunk-DZVH7HDD.cjs");
-var import_async = require("@dxos/async");
-var import_automerge = require("@dxos/automerge/automerge");
-var import_context = require("@dxos/context");
-var import_invariant = require("@dxos/invariant");
-var import_log = require("@dxos/log");
-var import_async2 = require("@dxos/async");
-var import_automerge2 = require("@dxos/automerge/automerge");
-var import_context2 = require("@dxos/context");
-var import_util = require("@dxos/util");
-var import_context3 = require("@dxos/context");
-var import_async3 = require("@dxos/async");
-var import_automerge3 = require("@dxos/automerge/automerge");
-var import_automerge_repo = require("@dxos/automerge/automerge-repo");
-var import_context4 = require("@dxos/context");
-var import_invariant2 = require("@dxos/invariant");
-var import_keys = require("@dxos/keys");
-var import_log2 = require("@dxos/log");
-var import_protocols = require("@dxos/protocols");
-var import_tracing = require("@dxos/tracing");
-var import_async4 = require("@dxos/async");
-var import_automerge_repo2 = require("@dxos/automerge/automerge-repo");
-var import_context5 = require("@dxos/context");
-var import_invariant3 = require("@dxos/invariant");
-var import_log3 = require("@dxos/log");
-var import_util2 = require("@dxos/util");
-var import_protocols2 = require("@dxos/protocols");
-var import_indexing = require("@dxos/indexing");
-var import_invariant4 = require("@dxos/invariant");
-var import_keys2 = require("@dxos/keys");
-var import_invariant5 = require("@dxos/invariant");
-var import_keys3 = require("@dxos/keys");
-var import_log4 = require("@dxos/log");
-var import_util3 = require("@dxos/util");
-var A2 = __toESM(require("@dxos/automerge/automerge"));
-var import_automerge_repo3 = require("@dxos/automerge/automerge-repo");
-var import_context6 = require("@dxos/context");
-var import_invariant6 = require("@dxos/invariant");
-var import_log5 = require("@dxos/log");
-var import_teleport_extension_automerge_replicator = require("@dxos/teleport-extension-automerge-replicator");
-var import_tracing2 = require("@dxos/tracing");
-var import_util4 = require("@dxos/util");
-var import_codec_protobuf = require("@dxos/codec-protobuf");
-var import_invariant7 = require("@dxos/invariant");
-var import_keys4 = require("@dxos/keys");
-var import_log6 = require("@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 import_context.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) {
-      import_log.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) => {
-        import_log.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 import_async.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) => import_automerge.next.loadIncremental(doc2, mutation));
-        this._startSync(doc);
-      } else {
-        this._writeMutation(documentId, mutation);
-      }
-    }
-  }
-  _startSync(doc) {
-    if (this._syncStates.has(doc.documentId)) {
-      import_log.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);
-    (0, import_invariant.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 ? import_automerge.next.saveSince(doc, syncState.lastSentHead) : import_automerge.next.save(doc);
-    if (mutation.length === 0) {
-      return;
-    }
-    syncState.lastSentHead = import_automerge.next.getHeads(doc);
-    return mutation;
-  }
-  _writeMutation(documentId, mutation) {
-    const syncState = this._syncStates.get(documentId);
-    (0, import_invariant.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 = import_automerge.next.getHeads(doc);
-      const newDoc = import_automerge.next.loadIncremental(doc, mutation);
-      if (import_automerge.next.equals(headsBefore, syncState.lastSentHead)) {
-        syncState.lastSentHead = import_automerge.next.getHeads(newDoc);
-      }
-      return newDoc;
-    });
-  }
-};
-var MIN_QUERY_INTERVAL = 5e3;
-var POLL_INTERVAL = 3e4;
-var CollectionSynchronizer = class extends import_context2.Resource {
-  constructor(params) {
-    super();
-    this._perCollectionStates = /* @__PURE__ */ new Map();
-    this._connectedPeers = /* @__PURE__ */ new Set();
-    this.remoteStateUpdated = new import_async2.Event();
-    this._sendCollectionState = params.sendCollectionState;
-    this._queryCollectionState = params.queryCollectionState;
-    this._shouldSyncCollection = params.shouldSyncCollection;
-  }
-  async _open(ctx) {
-    (0, import_async2.scheduleTaskInterval)(this._ctx, async () => {
-      for (const collectionId of this._perCollectionStates.keys()) {
-        this.refreshCollection(collectionId);
-        await (0, import_async2.asyncReturn)();
-      }
-    }, POLL_INTERVAL);
-  }
-  getRegisteredCollectionIds() {
-    return [
-      ...this._perCollectionStates.keys()
-    ];
-  }
-  getLocalCollectionState(collectionId) {
-    return this._getPerCollectionState(collectionId).localState;
-  }
-  setLocalCollectionState(collectionId, state) {
-    this._getPerCollectionState(collectionId).localState = state;
-    queueMicrotask(async () => {
-      if (!this._ctx.disposed) {
-        this._refreshInterestedPeers(collectionId);
-        this.refreshCollection(collectionId);
-      }
-    });
-  }
-  getRemoteCollectionStates(collectionId) {
-    return this._getPerCollectionState(collectionId).remoteStates;
-  }
-  refreshCollection(collectionId) {
-    let scheduleAnotherRefresh = false;
-    const state = this._getPerCollectionState(collectionId);
-    for (const peerId of this._connectedPeers) {
-      if (state.interestedPeers.has(peerId)) {
-        const lastQueried = state.lastQueried.get(peerId) ?? 0;
-        if (Date.now() - lastQueried > MIN_QUERY_INTERVAL) {
-          state.lastQueried.set(peerId, Date.now());
-          this._queryCollectionState(collectionId, peerId);
-        } else {
-          scheduleAnotherRefresh = true;
-        }
-      }
-    }
-    if (scheduleAnotherRefresh) {
-      (0, import_async2.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) {
-    validateCollectionState(state);
-    const perCollectionState = this._getPerCollectionState(collectionId);
-    perCollectionState.remoteStates.set(peerId, state);
-    this.remoteStateUpdated.emit({
-      peerId,
-      collectionId
-    });
-  }
-  _getPerCollectionState(collectionId) {
-    return (0, import_util.defaultMap)(this._perCollectionStates, collectionId, () => ({
-      localState: void 0,
-      remoteStates: /* @__PURE__ */ new Map(),
-      interestedPeers: /* @__PURE__ */ new Set(),
-      lastQueried: /* @__PURE__ */ new Map()
-    }));
-  }
-  _refreshInterestedPeers(collectionId) {
-    for (const peerId of this._connectedPeers) {
-      if (this._shouldSyncCollection(collectionId, peerId)) {
-        this._getPerCollectionState(collectionId).interestedPeers.add(peerId);
-      } else {
-        this._getPerCollectionState(collectionId).interestedPeers.delete(peerId);
-      }
-    }
-  }
-};
-var diffCollectionState = (local, remote) => {
-  const allDocuments = /* @__PURE__ */ new Set([
-    ...Object.keys(local.documents),
-    ...Object.keys(remote.documents)
-  ]);
-  const different = [];
-  for (const documentId of allDocuments) {
-    if (!local.documents[documentId] || !remote.documents[documentId] || !import_automerge2.next.equals(local.documents[documentId], remote.documents[documentId])) {
-      different.push(documentId);
-    }
-  }
-  return {
-    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(":");
-};
-var LevelDBStorageAdapter = class extends import_context3.Resource {
-  constructor(_params) {
-    super();
-    this._params = _params;
-  }
-  async load(keyArray) {
-    try {
-      if (this._lifecycleState !== import_context3.LifecycleState.OPEN) {
-        return void 0;
-      }
-      const startMs = Date.now();
-      const chunk = await this._params.db.get(keyArray, {
-        ...encodingOptions
-      });
-      this._params.monitor?.recordBytesLoaded(chunk.byteLength);
-      this._params.monitor?.recordLoadDuration(Date.now() - startMs);
-      return chunk;
-    } catch (err) {
-      if (isLevelDbNotFoundError(err)) {
-        return void 0;
-      }
-      throw err;
-    }
-  }
-  async save(keyArray, binary) {
-    if (this._lifecycleState !== import_context3.LifecycleState.OPEN) {
-      return void 0;
-    }
-    const startMs = Date.now();
-    const batch = this._params.db.batch();
-    await this._params.callbacks?.beforeSave?.({
-      path: keyArray,
-      batch
-    });
-    batch.put(keyArray, Buffer.from(binary), {
-      ...encodingOptions
-    });
-    await batch.write();
-    this._params.monitor?.recordBytesStored(binary.byteLength);
-    await this._params.callbacks?.afterSave?.(keyArray);
-    this._params.monitor?.recordStoreDuration(Date.now() - startMs);
-  }
-  async remove(keyArray) {
-    if (this._lifecycleState !== import_context3.LifecycleState.OPEN) {
-      return void 0;
-    }
-    await this._params.db.del(keyArray, {
-      ...encodingOptions
-    });
-  }
-  async loadRange(keyPrefix) {
-    if (this._lifecycleState !== import_context3.LifecycleState.OPEN) {
-      return [];
-    }
-    const startMs = Date.now();
-    const result = [];
-    for await (const [key, value] of this._params.db.iterator({
-      gte: keyPrefix,
-      lte: [
-        ...keyPrefix,
-        "\uFFFF"
-      ],
-      ...encodingOptions
-    })) {
-      result.push({
-        key,
-        data: value
-      });
-      this._params.monitor?.recordBytesLoaded(value.byteLength);
-    }
-    this._params.monitor?.recordLoadDuration(Date.now() - startMs);
-    return result;
-  }
-  async removeRange(keyPrefix) {
-    if (this._lifecycleState !== import_context3.LifecycleState.OPEN) {
-      return void 0;
-    }
-    const batch = this._params.db.batch();
-    for await (const [key] of this._params.db.iterator({
-      gte: keyPrefix,
-      lte: [
-        ...keyPrefix,
-        "\uFFFF"
-      ],
-      ...encodingOptions
-    })) {
-      batch.del(key, {
-        ...encodingOptions
-      });
-    }
-    await batch.write();
-  }
-};
-var keyEncoder = {
-  encode: (key) => Buffer.from(key.map((k) => k.replaceAll("%", "%25").replaceAll("-", "%2D")).join("-")),
-  decode: (key) => Buffer.from(key).toString().split("-").map((k) => k.replaceAll("%2D", "-").replaceAll("%25", "%")),
-  format: "buffer"
-};
-var encodingOptions = {
-  keyEncoding: keyEncoder,
-  valueEncoding: "buffer"
-};
-var isLevelDbNotFoundError = (err) => err.code === "LEVEL_NOT_FOUND";
-var isCollectionQueryMessage = (message) => message.type === import_protocols2.MESSAGE_TYPE_COLLECTION_QUERY;
-var isCollectionStateMessage = (message) => message.type === import_protocols2.MESSAGE_TYPE_COLLECTION_STATE;
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts";
-var EchoNetworkAdapter = class extends import_automerge_repo2.NetworkAdapter {
-  constructor(_params) {
-    super();
-    this._params = _params;
-    this._replicators = /* @__PURE__ */ new Set();
-    this._connections = /* @__PURE__ */ new Map();
-    this._lifecycleState = import_context5.LifecycleState.CLOSED;
-    this._connected = new import_async4.Trigger();
-  }
-  connect(peerId, peerMetadata) {
-    this.peerId = peerId;
-    this.peerMetadata = peerMetadata;
-    this._connected.wake();
-  }
-  send(message) {
-    this._send(message);
-  }
-  disconnect() {
-  }
-  async open() {
-    if (this._lifecycleState === import_context5.LifecycleState.OPEN) {
-      return;
-    }
-    this._lifecycleState = import_context5.LifecycleState.OPEN;
-    (0, import_log3.log)("emit ready", void 0, {
-      F: __dxlog_file2,
-      L: 81,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.emit("ready", {
-      network: this
-    });
-  }
-  async close() {
-    if (this._lifecycleState === import_context5.LifecycleState.CLOSED) {
-      return this;
-    }
-    for (const replicator of this._replicators) {
-      await replicator.disconnect();
-    }
-    this._replicators.clear();
-    this._lifecycleState = import_context5.LifecycleState.CLOSED;
-  }
-  async whenConnected() {
-    await this._connected.wait({
-      timeout: 1e4
-    });
-  }
-  async addReplicator(replicator) {
-    (0, import_invariant3.invariant)(this._lifecycleState === import_context5.LifecycleState.OPEN, void 0, {
-      F: __dxlog_file2,
-      L: 107,
-      S: this,
-      A: [
-        "this._lifecycleState === LifecycleState.OPEN",
-        ""
-      ]
-    });
-    (0, import_invariant3.invariant)(this.peerId, void 0, {
-      F: __dxlog_file2,
-      L: 108,
-      S: this,
-      A: [
-        "this.peerId",
-        ""
-      ]
-    });
-    (0, import_invariant3.invariant)(!this._replicators.has(replicator), void 0, {
-      F: __dxlog_file2,
-      L: 109,
-      S: this,
-      A: [
-        "!this._replicators.has(replicator)",
-        ""
-      ]
-    });
-    this._replicators.add(replicator);
-    await replicator.connect({
-      peerId: this.peerId,
-      onConnectionOpen: this._onConnectionOpen.bind(this),
-      onConnectionClosed: this._onConnectionClosed.bind(this),
-      onConnectionAuthScopeChanged: this._onConnectionAuthScopeChanged.bind(this),
-      isDocumentInRemoteCollection: this._params.isDocumentInRemoteCollection,
-      getContainingSpaceForDocument: this._params.getContainingSpaceForDocument,
-      getContainingSpaceIdForDocument: async (documentId) => {
-        const key = await this._params.getContainingSpaceForDocument(documentId);
-        return key ? (0, import_chunk_DZVH7HDD.createIdFromSpaceKey)(key) : null;
-      }
-    });
-  }
-  async removeReplicator(replicator) {
-    (0, import_invariant3.invariant)(this._lifecycleState === import_context5.LifecycleState.OPEN, void 0, {
-      F: __dxlog_file2,
-      L: 128,
-      S: this,
-      A: [
-        "this._lifecycleState === LifecycleState.OPEN",
-        ""
-      ]
-    });
-    (0, import_invariant3.invariant)(this._replicators.has(replicator), void 0, {
-      F: __dxlog_file2,
-      L: 129,
-      S: this,
-      A: [
-        "this._replicators.has(replicator)",
-        ""
-      ]
-    });
-    await replicator.disconnect();
-    this._replicators.delete(replicator);
-  }
-  async shouldAdvertise(peerId, params) {
-    const connection = this._connections.get(peerId);
-    if (!connection) {
-      return false;
-    }
-    return connection.connection.shouldAdvertise(params);
-  }
-  shouldSyncCollection(peerId, params) {
-    const connection = this._connections.get(peerId);
-    if (!connection) {
-      return false;
-    }
-    return connection.connection.shouldSyncCollection(params);
-  }
-  queryCollectionState(collectionId, targetId) {
-    const message = {
-      type: "collection-query",
-      senderId: this.peerId,
-      targetId,
-      collectionId
-    };
-    this._send(message);
-  }
-  sendCollectionState(collectionId, targetId, state) {
-    const message = {
-      type: "collection-state",
-      senderId: this.peerId,
-      targetId,
-      collectionId,
-      state
-    };
-    this._send(message);
-  }
-  _send(message) {
-    const connectionEntry = this._connections.get(message.targetId);
-    if (!connectionEntry) {
-      throw new Error("Connection not found.");
-    }
-    const writeStart = Date.now();
-    connectionEntry.writer.write(message).then(() => {
-      const durationMs = Date.now() - writeStart;
-      this._params.monitor?.recordMessageSent(message, durationMs);
-    }).catch((err) => {
-      if (connectionEntry.isOpen) {
-        import_log3.log.catch(err, void 0, {
-          F: __dxlog_file2,
-          L: 189,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-      this._params.monitor?.recordMessageSendingFailed(message);
-    });
-  }
-  // TODO(dmaretskyi): Remove.
-  getPeersInterestedInCollection(collectionId) {
-    return Array.from(this._connections.values()).map((connection) => {
-      return connection.connection.shouldSyncCollection({
-        collectionId
-      }) ? connection.connection.peerId : null;
-    }).filter(import_util2.nonNullable);
-  }
-  _onConnectionOpen(connection) {
-    (0, import_log3.log)("Connection opened", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file2,
-      L: 207,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_invariant3.invariant)(!this._connections.has(connection.peerId), void 0, {
-      F: __dxlog_file2,
-      L: 208,
-      S: this,
-      A: [
-        "!this._connections.has(connection.peerId as PeerId)",
-        ""
-      ]
-    });
-    const reader = connection.readable.getReader();
-    const writer = connection.writable.getWriter();
-    const connectionEntry = {
-      connection,
-      reader,
-      writer,
-      isOpen: true
-    };
-    this._connections.set(connection.peerId, connectionEntry);
-    queueMicrotask(async () => {
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            break;
-          }
-          this._onMessage(value);
-        }
-      } catch (err) {
-        if (connectionEntry.isOpen) {
-          import_log3.log.catch(err, void 0, {
-            F: __dxlog_file2,
-            L: 227,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        }
-      }
-    });
-    (0, import_log3.log)("emit peer-candidate", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file2,
-      L: 232,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._emitPeerCandidate(connection);
-    this._params.monitor?.recordPeerConnected(connection.peerId);
-  }
-  _onMessage(message) {
-    if (isCollectionQueryMessage(message)) {
-      this._params.onCollectionStateQueried(message.collectionId, message.senderId);
-    } else if (isCollectionStateMessage(message)) {
-      this._params.onCollectionStateReceived(message.collectionId, message.senderId, message.state);
-    } else {
-      this.emit("message", message);
-    }
-    this._params.monitor?.recordMessageReceived(message);
-  }
-  /**
-  * Trigger doc-synchronizer shared documents set recalculation. Happens on peer-candidate.
-  * TODO(y): replace with a proper API call when sharePolicy update becomes supported by automerge-repo
-  */
-  _onConnectionAuthScopeChanged(connection) {
-    (0, import_log3.log)("Connection auth scope changed", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file2,
-      L: 253,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const entry = this._connections.get(connection.peerId);
-    (0, import_invariant3.invariant)(entry, void 0, {
-      F: __dxlog_file2,
-      L: 255,
-      S: this,
-      A: [
-        "entry",
-        ""
-      ]
-    });
-    this.emit("peer-disconnected", {
-      peerId: connection.peerId
-    });
-    this._emitPeerCandidate(connection);
-  }
-  _onConnectionClosed(connection) {
-    (0, import_log3.log)("Connection closed", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file2,
-      L: 261,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const entry = this._connections.get(connection.peerId);
-    (0, import_invariant3.invariant)(entry, void 0, {
-      F: __dxlog_file2,
-      L: 263,
-      S: this,
-      A: [
-        "entry",
-        ""
-      ]
-    });
-    entry.isOpen = false;
-    this.emit("peer-disconnected", {
-      peerId: connection.peerId
-    });
-    this._params.monitor?.recordPeerDisconnected(connection.peerId);
-    void entry.reader.cancel().catch((err) => import_log3.log.catch(err, void 0, {
-      F: __dxlog_file2,
-      L: 269,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-    void entry.writer.abort().catch((err) => import_log3.log.catch(err, void 0, {
-      F: __dxlog_file2,
-      L: 270,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-    this._connections.delete(connection.peerId);
-  }
-  _emitPeerCandidate(connection) {
-    this.emit("peer-candidate", {
-      peerId: connection.peerId,
-      peerMetadata: createEchoPeerMetadata()
-    });
-  }
-};
-_ts_decorate([
-  import_async4.synchronized
-], EchoNetworkAdapter.prototype, "open", null);
-_ts_decorate([
-  import_async4.synchronized
-], EchoNetworkAdapter.prototype, "close", null);
-_ts_decorate([
-  import_async4.synchronized
-], EchoNetworkAdapter.prototype, "addReplicator", null);
-_ts_decorate([
-  import_async4.synchronized
-], EchoNetworkAdapter.prototype, "removeReplicator", null);
-var createEchoPeerMetadata = () => ({
-  // TODO(dmaretskyi): Refactor this.
-  dxos_peerSource: "EchoNetworkAdapter"
-});
-var isEchoPeerMetadata = (metadata) => metadata?.dxos_peerSource === "EchoNetworkAdapter";
-var HeadsStore = class {
-  constructor({ db }) {
-    this._db = db;
-  }
-  setHeads(documentId, heads, batch) {
-    batch.put(documentId, heads, {
-      sublevel: this._db,
-      keyEncoding: "utf8",
-      valueEncoding: import_indexing.headsEncoding
-    });
-  }
-  // TODO(dmaretskyi): Make batched.
-  async getHeads(documentIds) {
-    return this._db.getMany(documentIds, {
-      keyEncoding: "utf8",
-      valueEncoding: import_indexing.headsEncoding
-    });
-  }
-};
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
-var AutomergeHost = class extends import_context4.Resource {
-  constructor({ db, indexMetadataStore, dataMonitor }) {
-    super();
-    this._collectionSynchronizer = new CollectionSynchronizer({
-      queryCollectionState: this._queryCollectionState.bind(this),
-      sendCollectionState: this._sendCollectionState.bind(this),
-      shouldSyncCollection: this._shouldSyncCollection.bind(this)
-    });
-    this._db = db;
-    this._storage = new LevelDBStorageAdapter({
-      db: db.sublevel("automerge"),
-      callbacks: {
-        beforeSave: async (params) => this._beforeSave(params),
-        afterSave: async (key) => this._afterSave(key)
-      },
-      monitor: dataMonitor
-    });
-    this._echoNetworkAdapter = new EchoNetworkAdapter({
-      getContainingSpaceForDocument: this._getContainingSpaceForDocument.bind(this),
-      isDocumentInRemoteCollection: this._isDocumentInRemoteCollection.bind(this),
-      onCollectionStateQueried: this._onCollectionStateQueried.bind(this),
-      onCollectionStateReceived: this._onCollectionStateReceived.bind(this),
-      monitor: dataMonitor
-    });
-    this._headsStore = new HeadsStore({
-      db: db.sublevel("heads")
-    });
-    this._indexMetadataStore = indexMetadataStore;
-  }
-  async _open() {
-    this._peerId = `host-${import_keys.PublicKey.random().toHex()}`;
-    await this._storage.open?.();
-    this._repo = new import_automerge_repo.Repo({
-      peerId: this._peerId,
-      sharePolicy: this._sharePolicy.bind(this),
-      storage: this._storage,
-      network: [
-        // Upstream swarm.
-        this._echoNetworkAdapter
-      ]
-    });
-    import_async3.Event.wrap(this._echoNetworkAdapter, "peer-candidate").on(this._ctx, (e) => this._onPeerConnected(e.peerId));
-    import_async3.Event.wrap(this._echoNetworkAdapter, "peer-disconnected").on(this._ctx, (e) => this._onPeerDisconnected(e.peerId));
-    this._collectionSynchronizer.remoteStateUpdated.on(this._ctx, ({ collectionId, peerId }) => {
-      this._onRemoteCollectionStateUpdated(collectionId, peerId);
-    });
-    await this._echoNetworkAdapter.open();
-    await this._collectionSynchronizer.open();
-    await this._echoNetworkAdapter.open();
-    await this._echoNetworkAdapter.whenConnected();
-  }
-  async _close() {
-    await this._collectionSynchronizer.close();
-    await this._storage.close?.();
-    await this._echoNetworkAdapter.close();
-    await this._ctx.dispose();
-  }
-  /**
-  * @deprecated To be abstracted away.
-  */
-  get repo() {
-    return this._repo;
-  }
-  get peerId() {
-    return this._peerId;
-  }
-  get loadedDocsCount() {
-    return Object.keys(this._repo.handles).length;
-  }
-  async addReplicator(replicator) {
-    await this._echoNetworkAdapter.addReplicator(replicator);
-  }
-  async removeReplicator(replicator) {
-    await this._echoNetworkAdapter.removeReplicator(replicator);
-  }
-  /**
-  * Loads the document handle from the repo and waits for it to be ready.
-  */
-  async loadDoc(ctx, documentId, opts) {
-    let handle;
-    if (typeof documentId === "string") {
-      handle = this._repo.handles[documentId];
-    }
-    if (!handle) {
-      handle = this._repo.find(documentId);
-    }
-    if (!handle.isReady()) {
-      if (!opts?.timeout) {
-        await (0, import_context4.cancelWithContext)(ctx, handle.whenReady());
-      } else {
-        await (0, import_context4.cancelWithContext)(ctx, (0, import_async3.asyncTimeout)(handle.whenReady(), opts.timeout));
-      }
-    }
-    return handle;
-  }
-  /**
-  * Create new persisted document.
-  */
-  createDoc(initialValue, opts) {
-    if (opts?.preserveHistory) {
-      if (!(0, import_automerge3.isAutomerge)(initialValue)) {
-        throw new TypeError("Initial value must be an Automerge document");
-      }
-      return this._repo.import((0, import_automerge3.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 && (0, import_automerge3.equals)(currentHeads, targetHeads));
-    });
-    if (headsToWait.length > 0) {
-      await Promise.all(headsToWait.map(async (entry, index) => {
-        const handle = await this.loadDoc(import_context4.Context.default(void 0, {
-          F: __dxlog_file3,
-          L: 227
-        }), entry.documentId);
-        await waitForHeads(handle, entry.heads);
-      }));
-    }
-    await this._repo.flush(documentIds.filter((documentId) => !!this._repo.handles[documentId]));
-  }
-  async reIndexHeads(documentIds) {
-    for (const documentId of documentIds) {
-      import_log2.log.info("re-indexing heads for document", {
-        documentId
-      }, {
-        F: __dxlog_file3,
-        L: 239,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const handle = this._repo.find(documentId);
-      await handle.whenReady([
-        "ready",
-        "requesting"
-      ]);
-      if (handle.inState([
-        "requesting"
-      ])) {
-        import_log2.log.warn("document is not available locally, skipping", {
-          documentId
-        }, {
-          F: __dxlog_file3,
-          L: 243,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        continue;
-      }
-      const doc = handle.docSync();
-      (0, import_invariant2.invariant)(doc, void 0, {
-        F: __dxlog_file3,
-        L: 248,
-        S: this,
-        A: [
-          "doc",
-          ""
-        ]
-      });
-      const heads = (0, import_automerge3.getHeads)(doc);
-      const batch = this._db.batch();
-      this._headsStore.setHeads(documentId, heads, batch);
-      await batch.write();
-    }
-    import_log2.log.info("done re-indexing heads", void 0, {
-      F: __dxlog_file3,
-      L: 255,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
-  // Hosts, running in the worker, don't share documents unless requested by other peers.
-  // NOTE: If both peers return sharePolicy=false the replication will not happen
-  // https://github.com/automerge/automerge-repo/pull/292
-  async _sharePolicy(peerId, documentId) {
-    if (peerId.startsWith("client-")) {
-      return false;
-    }
-    if (!documentId) {
-      return false;
-    }
-    const peerMetadata = this.repo.peerMetadataByPeerId[peerId];
-    if (isEchoPeerMetadata(peerMetadata)) {
-      return this._echoNetworkAdapter.shouldAdvertise(peerId, {
-        documentId
-      });
-    }
-    return false;
-  }
-  async _beforeSave({ path, batch }) {
-    const handle = this._repo.handles[path[0]];
-    if (!handle) {
-      return;
-    }
-    const doc = handle.docSync();
-    if (!doc) {
-      return;
-    }
-    const heads = (0, import_automerge3.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) => import_protocols.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 = (0, import_automerge3.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 import_keys.PublicKey.from(spaceKeyHex);
-  }
-  /**
-  * Flush documents to disk.
-  */
-  async flush({ documentIds } = {}) {
-    await this._repo.flush(documentIds);
-  }
-  async getHeads(documentIds) {
-    const result = [];
-    const storeRequestIds = [];
-    const storeResultIndices = [];
-    for (const documentId of documentIds) {
-      const doc = this._repo.handles[documentId]?.docSync();
-      if (doc) {
-        result.push((0, import_automerge3.getHeads)(doc));
-      } else {
-        storeRequestIds.push(documentId);
-        storeResultIndices.push(result.length);
-        result.push(void 0);
-      }
-    }
-    if (storeRequestIds.length > 0) {
-      const storedHeads = await this._headsStore.getHeads(storeRequestIds);
-      for (let i = 0; i < storedHeads.length; i++) {
-        result[storeResultIndices[i]] = storedHeads[i];
-      }
-    }
-    return result;
-  }
-  //
-  // Collection sync.
-  //
-  getLocalCollectionState(collectionId) {
-    return this._collectionSynchronizer.getLocalCollectionState(collectionId);
-  }
-  getRemoteCollectionStates(collectionId) {
-    return this._collectionSynchronizer.getRemoteCollectionStates(collectionId);
-  }
-  refreshCollection(collectionId) {
-    this._collectionSynchronizer.refreshCollection(collectionId);
-  }
-  async getCollectionSyncState(collectionId) {
-    const result = {
-      peers: []
-    };
-    const localState = this.getLocalCollectionState(collectionId);
-    const remoteState = this.getRemoteCollectionStates(collectionId);
-    if (!localState) {
-      return result;
-    }
-    for (const [peerId, state] of remoteState) {
-      const diff = diffCollectionState(localState, state);
-      result.peers.push({
-        peerId,
-        differentDocuments: diff.different.length
-      });
-    }
-    return result;
-  }
-  /**
-  * Update the local collection state based on the locally stored document heads.
-  */
-  async updateLocalCollectionState(collectionId, documentIds) {
-    const heads = await this.getHeads(documentIds);
-    const documents = Object.fromEntries(heads.map((heads2, index) => [
-      documentIds[index],
-      heads2 ?? []
-    ]));
-    this._collectionSynchronizer.setLocalCollectionState(collectionId, {
-      documents
-    });
-  }
-  _onCollectionStateQueried(collectionId, peerId) {
-    this._collectionSynchronizer.onCollectionStateQueried(collectionId, peerId);
-  }
-  _onCollectionStateReceived(collectionId, peerId, state) {
-    this._collectionSynchronizer.onRemoteStateReceived(collectionId, peerId, decodeCollectionState(state));
-  }
-  _queryCollectionState(collectionId, peerId) {
-    this._echoNetworkAdapter.queryCollectionState(collectionId, peerId);
-  }
-  _sendCollectionState(collectionId, peerId, state) {
-    this._echoNetworkAdapter.sendCollectionState(collectionId, peerId, encodeCollectionState(state));
-  }
-  _onPeerConnected(peerId) {
-    this._collectionSynchronizer.onConnectionOpen(peerId);
-  }
-  _onPeerDisconnected(peerId) {
-    this._collectionSynchronizer.onConnectionClosed(peerId);
-  }
-  _onRemoteCollectionStateUpdated(collectionId, peerId) {
-    const localState = this._collectionSynchronizer.getLocalCollectionState(collectionId);
-    const remoteState = this._collectionSynchronizer.getRemoteCollectionStates(collectionId).get(peerId);
-    if (!localState || !remoteState) {
-      return;
-    }
-    const { different } = diffCollectionState(localState, remoteState);
-    if (different.length === 0) {
-      return;
-    }
-    import_log2.log.info("replication documents after collection sync", {
-      count: different.length
-    }, {
-      F: __dxlog_file3,
-      L: 475,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    for (const documentId of different) {
-      this._repo.find(documentId);
-    }
-  }
-  _onHeadsChanged(documentId, heads) {
-    for (const collectionId of this._collectionSynchronizer.getRegisteredCollectionIds()) {
-      const state = this._collectionSynchronizer.getLocalCollectionState(collectionId);
-      if (state?.documents[documentId]) {
-        const newState = structuredClone(state);
-        newState.documents[documentId] = heads;
-        this._collectionSynchronizer.setLocalCollectionState(collectionId, newState);
-      }
-    }
-  }
-};
-_ts_decorate2([
-  import_tracing.trace.info()
-], AutomergeHost.prototype, "_peerId", void 0);
-_ts_decorate2([
-  import_tracing.trace.info({
-    depth: null
-  })
-], AutomergeHost.prototype, "_automergePeers", null);
-_ts_decorate2([
-  import_tracing.trace.span({
-    showInBrowserTimeline: true
-  })
-], AutomergeHost.prototype, "flush", null);
-AutomergeHost = _ts_decorate2([
-  import_tracing.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 import_async3.Event.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 !!(0, import_automerge3.getBackend)(doc).getChangeByHash(changeHash);
-};
-var decodeCollectionState = (state) => {
-  (0, import_invariant2.invariant)(typeof state === "object" && state !== null, "Invalid state", {
-    F: __dxlog_file3,
-    L: 528,
-    S: void 0,
-    A: [
-      "typeof state === 'object' && state !== null",
-      "'Invalid state'"
-    ]
-  });
-  return state;
-};
-var encodeCollectionState = (state) => {
-  return state;
-};
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/space-collection.ts";
-var deriveCollectionIdFromSpaceId = (spaceId) => `space:${spaceId}`;
-var getSpaceIdFromCollectionId = (collectionId) => {
-  const spaceId = collectionId.replace(/^space:/, "");
-  (0, import_invariant4.invariant)(import_keys2.SpaceId.isValid(spaceId), void 0, {
-    F: __dxlog_file4,
-    L: 12,
-    S: void 0,
-    A: [
-      "SpaceId.isValid(spaceId)",
-      ""
-    ]
-  });
-  return spaceId;
-};
-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 import_teleport_extension_automerge_replicator.AutomergeReplicator(...params);
-var MeshReplicatorConnection = class extends import_context6.Resource {
-  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) => {
-        (0, import_invariant6.invariant)(this._isEnabled, "Writing to a disabled connection", {
-          F: __dxlog_file5,
-          L: 49,
-          S: this,
-          A: [
-            "this._isEnabled",
-            "'Writing to a disabled connection'"
-          ]
-        });
-        try {
-          logSendSync(message);
-          await this.replicatorExtension.sendSyncMessage({
-            payload: import_automerge_repo3.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;
-          (0, import_log5.log)("onStartReplication", {
-            id: info.id,
-            thisPeerId: this.peerId,
-            remotePeerId: remotePeerId.toHex()
-          }, {
-            F: __dxlog_file5,
-            L: 84,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._params.onRemoteConnected();
-        },
-        onSyncMessage: async ({ payload }) => {
-          if (!this._isEnabled) {
-            return;
-          }
-          const message = import_automerge_repo3.cbor.decode(payload);
-          readableStreamController.enqueue(message);
-        },
-        onClose: async () => {
-          this._disconnectIfEnabled();
-        }
-      }
-    ]);
-  }
-  _disconnectIfEnabled() {
-    if (this._isEnabled) {
-      this._params.onRemoteDisconnected();
-    }
-  }
-  get peerId() {
-    (0, import_invariant6.invariant)(this._remotePeerId != null, "Remote peer has not connected yet.", {
-      F: __dxlog_file5,
-      L: 110,
-      S: this,
-      A: [
-        "this._remotePeerId != null",
-        "'Remote peer has not connected yet.'"
-      ]
-    });
-    return this._remotePeerId;
-  }
-  async shouldAdvertise(params) {
-    return this._params.shouldAdvertise(params);
-  }
-  shouldSyncCollection(params) {
-    return this._params.shouldSyncCollection(params);
-  }
-  /**
-  * Start exchanging messages with the remote peer.
-  * Call after the remote peer has connected.
-  */
-  enable() {
-    (0, import_invariant6.invariant)(this._remotePeerId != null, "Remote peer has not connected yet.", {
-      F: __dxlog_file5,
-      L: 127,
-      S: this,
-      A: [
-        "this._remotePeerId != null",
-        "'Remote peer has not connected yet.'"
-      ]
-    });
-    this._isEnabled = true;
-  }
-  /**
-  * Stop exchanging messages with the remote peer.
-  */
-  disable() {
-    this._isEnabled = false;
-  }
-};
-var logSendSync = (message) => {
-  (0, import_log5.log)("sendSyncMessage", () => {
-    const decodedSyncMessage = message.type === "sync" && message.data ? A2.decodeSyncMessage(message.data) : void 0;
-    return {
-      sync: decodedSyncMessage && {
-        headsLength: decodedSyncMessage.heads.length,
-        requesting: decodedSyncMessage.need.length > 0,
-        sendingChanges: decodedSyncMessage.changes.length > 0
-      },
-      type: message.type,
-      from: message.senderId,
-      to: message.targetId
-    };
-  }, {
-    F: __dxlog_file5,
-    L: 140,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-};
-var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts";
-var MeshEchoReplicator = class {
-  constructor() {
-    this._connections = /* @__PURE__ */ new Set();
-    this._connectionsPerPeer = /* @__PURE__ */ new Map();
-    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) {
-    (0, import_invariant5.invariant)(this._context, void 0, {
-      F: __dxlog_file6,
-      L: 56,
-      S: this,
-      A: [
-        "this._context",
-        ""
-      ]
-    });
-    const connection = new MeshReplicatorConnection({
-      ownPeerId: this._context.peerId,
-      replicatorFactory: extensionFactory,
-      onRemoteConnected: async () => {
-        (0, import_log4.log)("onRemoteConnected", {
-          peerId: connection.peerId
-        }, {
-          F: __dxlog_file6,
-          L: 62,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        (0, import_invariant5.invariant)(this._context, void 0, {
-          F: __dxlog_file6,
-          L: 63,
-          S: this,
-          A: [
-            "this._context",
-            ""
-          ]
-        });
-        if (this._connectionsPerPeer.has(connection.peerId)) {
-          this._context.onConnectionAuthScopeChanged(connection);
-        } else {
-          this._connectionsPerPeer.set(connection.peerId, connection);
-          this._context.onConnectionOpen(connection);
-          connection.enable();
-        }
-      },
-      onRemoteDisconnected: async () => {
-        (0, import_log4.log)("onRemoteDisconnected", {
-          peerId: connection.peerId
-        }, {
-          F: __dxlog_file6,
-          L: 74,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._context?.onConnectionClosed(connection);
-        this._connectionsPerPeer.delete(connection.peerId);
-        connection.disable();
-        this._connections.delete(connection);
-      },
-      shouldAdvertise: async (params) => {
-        (0, import_log4.log)("shouldAdvertise", {
-          peerId: connection.peerId,
-          documentId: params.documentId
-        }, {
-          F: __dxlog_file6,
-          L: 81,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        (0, import_invariant5.invariant)(this._context, void 0, {
-          F: __dxlog_file6,
-          L: 82,
-          S: this,
-          A: [
-            "this._context",
-            ""
-          ]
-        });
-        try {
-          const spaceKey = await this._context.getContainingSpaceForDocument(params.documentId);
-          if (!spaceKey) {
-            const remoteDocumentExists = await this._context.isDocumentInRemoteCollection({
-              documentId: params.documentId,
-              peerId: connection.peerId
-            });
-            (0, import_log4.log)("document not found locally for share policy check, accepting the remote document", {
-              peerId: connection.peerId,
-              documentId: params.documentId,
-              remoteDocumentExists
-            }, {
-              F: __dxlog_file6,
-              L: 90,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return remoteDocumentExists;
-          }
-          const spaceId = await (0, import_chunk_DZVH7HDD.createIdFromSpaceKey)(spaceKey);
-          const authorizedDevices = this._authorizedDevices.get(spaceId);
-          if (!connection.remoteDeviceKey) {
-            (0, import_log4.log)("device key not found for share policy check", {
-              peerId: connection.peerId,
-              documentId: params.documentId
-            }, {
-              F: __dxlog_file6,
-              L: 106,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return false;
-          }
-          const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
-          (0, import_log4.log)("share policy check", {
-            localPeer: this._context.peerId,
-            remotePeer: connection.peerId,
-            documentId: params.documentId,
-            deviceKey: connection.remoteDeviceKey,
-            spaceKey,
-            isAuthorized
-          }, {
-            F: __dxlog_file6,
-            L: 114,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          return isAuthorized;
-        } catch (err) {
-          import_log4.log.catch(err, void 0, {
-            F: __dxlog_file6,
-            L: 124,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          return false;
-        }
-      },
-      shouldSyncCollection: ({ collectionId }) => {
-        const spaceId = getSpaceIdFromCollectionId(collectionId);
-        const authorizedDevices = this._authorizedDevices.get(spaceId);
-        if (!connection.remoteDeviceKey) {
-          (0, import_log4.log)("device key not found for collection sync check", {
-            peerId: connection.peerId,
-            collectionId
-          }, {
-            F: __dxlog_file6,
-            L: 134,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          return false;
-        }
-        const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
-        return isAuthorized;
-      }
-    });
-    this._connections.add(connection);
-    return connection.replicatorExtension;
-  }
-  async authorizeDevice(spaceKey, deviceKey) {
-    (0, import_log4.log)("authorizeDevice", {
-      spaceKey,
-      deviceKey
-    }, {
-      F: __dxlog_file6,
-      L: 151,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const spaceId = await (0, import_chunk_DZVH7HDD.createIdFromSpaceKey)(spaceKey);
-    (0, import_util3.defaultMap)(this._authorizedDevices, spaceId, () => new import_util3.ComplexSet(import_keys3.PublicKey.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);
-        }
-      }
-    }
-  }
-};
-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 import_util4.CircularBuffer(100);
-    this._lastSentMessages = new import_util4.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: (0, import_util4.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) {
-        import_tracing2.trace.metrics.distribution(`dxos.echo.${metricName}-rate`, metric);
-        import_tracing2.trace.metrics.increment(`dxos.echo.${metricName}`, 1, {
-          tags: {
-            status: "busy"
-          }
-        });
-      } else {
-        import_tracing2.trace.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);
-    import_tracing2.trace.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);
-    import_tracing2.trace.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";
-    }
-    import_tracing2.trace.metrics.distribution(`dxos.echo.${metricsGroupName}.bytes-sent`, bytes, {
-      unit: "bytes",
-      tags
-    });
-    import_tracing2.trace.metrics.distribution(`dxos.echo.${metricsGroupName}.send-duration`, duration, {
-      unit: "millisecond",
-      tags
-    });
-    import_tracing2.trace.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);
-      import_tracing2.trace.metrics.distribution("dxos.echo.replication.bytes-received", bytes, {
-        unit: "bytes",
-        tags
-      });
-    } else {
-      import_tracing2.trace.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++;
-      import_tracing2.trace.metrics.increment("dxos.echo.replication.send-status", 1, {
-        unit: "bytes",
-        tags
-      });
-    } else {
-      import_tracing2.trace.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([
-  import_tracing2.trace.resource()
-], EchoDataMonitor);
-var isAutomergeProtocolMessage = (message) => {
-  return !(isCollectionQueryMessage(message) || isCollectionStateMessage(message));
-};
-var createSlidingWindow = (overrides) => new import_util4.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);
-};
-var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/data-service.ts";
-var DataServiceImpl = class {
-  constructor(params) {
-    this._subscriptions = /* @__PURE__ */ new Map();
-    this._automergeHost = params.automergeHost;
-    this._updateIndexes = params.updateIndexes;
-  }
-  subscribe(request) {
-    return new import_codec_protobuf.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) => import_log6.log.catch(err, void 0, {
-        F: __dxlog_file7,
-        L: 64,
-        S: this,
-        C: (f, a) => f(...a)
-      }));
-      return () => synchronizer.close();
-    });
-  }
-  async updateSubscription(request) {
-    const synchronizer = this._subscriptions.get(request.subscriptionId);
-    (0, import_invariant7.invariant)(synchronizer, "Subscription not found", {
-      F: __dxlog_file7,
-      L: 71,
-      S: this,
-      A: [
-        "synchronizer",
-        "'Subscription not found'"
-      ]
-    });
-    if (request.addIds?.length) {
-      await synchronizer.addDocuments(request.addIds);
-    }
-    if (request.removeIds?.length) {
-      await synchronizer.removeDocuments(request.removeIds);
-    }
-  }
-  async update(request) {
-    if (!request.updates) {
-      return;
-    }
-    const synchronizer = this._subscriptions.get(request.subscriptionId);
-    (0, import_invariant7.invariant)(synchronizer, "Subscription not found", {
-      F: __dxlog_file7,
-      L: 86,
-      S: this,
-      A: [
-        "synchronizer",
-        "'Subscription not found'"
-      ]
-    });
-    synchronizer.update(request.updates);
-  }
-  async flush(request) {
-    await this._automergeHost.flush(request);
-  }
-  async getDocumentHeads(request) {
-    const documentIds = request.documentIds;
-    if (!documentIds) {
-      return {
-        heads: {
-          entries: []
-        }
-      };
-    }
-    const heads = await this._automergeHost.getHeads(documentIds);
-    return {
-      heads: {
-        entries: heads.map((heads2, idx) => ({
-          documentId: documentIds[idx],
-          heads: heads2
-        }))
-      }
-    };
-  }
-  async waitUntilHeadsReplicated(request, options) {
-    await this._automergeHost.waitUntilHeadsReplicated(request.heads);
-  }
-  async reIndexHeads(request, options) {
-    await this._automergeHost.reIndexHeads(request.documentIds ?? []);
-  }
-  async updateIndexes() {
-    await this._updateIndexes();
-  }
-  async getSpaceSyncState(request, options) {
-    (0, import_invariant7.invariant)(import_keys4.SpaceId.isValid(request.spaceId), void 0, {
-      F: __dxlog_file7,
-      L: 127,
-      S: this,
-      A: [
-        "SpaceId.isValid(request.spaceId)",
-        ""
-      ]
-    });
-    const collectionId = deriveCollectionIdFromSpaceId(request.spaceId);
-    const state = await this._automergeHost.getCollectionSyncState(collectionId);
-    return {
-      peers: state.peers.map((peer) => ({
-        peerId: peer.peerId,
-        documentsToReconcile: peer.differentDocuments
-      }))
-    };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AutomergeHost,
-  DataServiceImpl,
-  DocumentsSynchronizer,
-  EchoDataMonitor,
-  LevelDBStorageAdapter,
-  MeshEchoReplicator,
-  deriveCollectionIdFromSpaceId,
-  diffCollectionState,
-  encodingOptions,
-  getSpaceIdFromCollectionId,
-  getSpaceKeyFromDoc
-});
-//# sourceMappingURL=chunk-5DH4KR2S.cjs.map