@dxos/echo-pipeline 0.6.2 → 0.6.3-main.0308ae2

package/dist/lib/node/index.cjs

@@ -18,1064 +18,42 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  AuthExtension: () => import_chunk_RH6TDRML.AuthExtension,
-  AuthStatus: () => import_chunk_RH6TDRML.AuthStatus,
-  AutomergeHost: () => AutomergeHost,
-  CredentialRetrieverExtension: () => import_chunk_RH6TDRML.CredentialRetrieverExtension,
-  CredentialServerExtension: () => import_chunk_RH6TDRML.CredentialServerExtension,
-  DataServiceImpl: () => import_chunk_RH6TDRML.DataServiceImpl,
-  DocumentsSynchronizer: () => import_chunk_RH6TDRML.DocumentsSynchronizer,
-  LevelDBStorageAdapter: () => LevelDBStorageAdapter,
-  MOCK_AUTH_PROVIDER: () => import_chunk_RH6TDRML.MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER: () => import_chunk_RH6TDRML.MOCK_AUTH_VERIFIER,
-  MeshEchoReplicator: () => MeshEchoReplicator,
-  MetadataStore: () => import_chunk_RH6TDRML.MetadataStore,
-  Pipeline: () => import_chunk_RH6TDRML.Pipeline,
-  SnapshotManager: () => import_chunk_RH6TDRML.SnapshotManager,
-  SnapshotStore: () => import_chunk_RH6TDRML.SnapshotStore,
-  Space: () => import_chunk_RH6TDRML.Space,
-  SpaceManager: () => import_chunk_RH6TDRML.SpaceManager,
-  SpaceProtocol: () => import_chunk_RH6TDRML.SpaceProtocol,
-  SpaceProtocolSession: () => import_chunk_RH6TDRML.SpaceProtocolSession,
-  TimeframeClock: () => import_chunk_RH6TDRML.TimeframeClock,
-  codec: () => import_chunk_RH6TDRML.codec,
-  createIdFromSpaceKey: () => import_chunk_RH6TDRML.createIdFromSpaceKey,
-  createMappedFeedWriter: () => import_chunk_RH6TDRML.createMappedFeedWriter,
-  encodingOptions: () => encodingOptions,
-  getSpaceKeyFromDoc: () => getSpaceKeyFromDoc,
-  hasInvitationExpired: () => import_chunk_RH6TDRML.hasInvitationExpired,
-  mapFeedIndexesToTimeframe: () => import_chunk_RH6TDRML.mapFeedIndexesToTimeframe,
-  mapTimeframeToFeedIndexes: () => import_chunk_RH6TDRML.mapTimeframeToFeedIndexes,
-  startAfter: () => import_chunk_RH6TDRML.startAfter,
-  valueEncoding: () => import_chunk_RH6TDRML.valueEncoding
+  AuthExtension: () => import_chunk_PT5LWMPA.AuthExtension,
+  AuthStatus: () => import_chunk_PT5LWMPA.AuthStatus,
+  AutomergeHost: () => import_chunk_PT5LWMPA.AutomergeHost,
+  CredentialRetrieverExtension: () => import_chunk_PT5LWMPA.CredentialRetrieverExtension,
+  CredentialServerExtension: () => import_chunk_PT5LWMPA.CredentialServerExtension,
+  DataServiceImpl: () => import_chunk_PT5LWMPA.DataServiceImpl,
+  DocumentsSynchronizer: () => import_chunk_PT5LWMPA.DocumentsSynchronizer,
+  LevelDBStorageAdapter: () => import_chunk_PT5LWMPA.LevelDBStorageAdapter,
+  MOCK_AUTH_PROVIDER: () => import_chunk_PT5LWMPA.MOCK_AUTH_PROVIDER,
+  MOCK_AUTH_VERIFIER: () => import_chunk_PT5LWMPA.MOCK_AUTH_VERIFIER,
+  MeshEchoReplicator: () => import_chunk_PT5LWMPA.MeshEchoReplicator,
+  MetadataStore: () => import_chunk_PT5LWMPA.MetadataStore,
+  Pipeline: () => import_chunk_PT5LWMPA.Pipeline,
+  SnapshotManager: () => import_chunk_PT5LWMPA.SnapshotManager,
+  SnapshotStore: () => import_chunk_PT5LWMPA.SnapshotStore,
+  Space: () => import_chunk_PT5LWMPA.Space,
+  SpaceManager: () => import_chunk_PT5LWMPA.SpaceManager,
+  SpaceProtocol: () => import_chunk_PT5LWMPA.SpaceProtocol,
+  SpaceProtocolSession: () => import_chunk_PT5LWMPA.SpaceProtocolSession,
+  TimeframeClock: () => import_chunk_PT5LWMPA.TimeframeClock,
+  codec: () => import_chunk_PT5LWMPA.codec,
+  createIdFromSpaceKey: () => import_chunk_PT5LWMPA.createIdFromSpaceKey,
+  createMappedFeedWriter: () => import_chunk_PT5LWMPA.createMappedFeedWriter,
+  deriveCollectionIdFromSpaceId: () => import_chunk_PT5LWMPA.deriveCollectionIdFromSpaceId,
+  diffCollectionState: () => import_chunk_PT5LWMPA.diffCollectionState,
+  encodingOptions: () => import_chunk_PT5LWMPA.encodingOptions,
+  getSpaceIdFromCollectionId: () => import_chunk_PT5LWMPA.getSpaceIdFromCollectionId,
+  getSpaceKeyFromDoc: () => import_chunk_PT5LWMPA.getSpaceKeyFromDoc,
+  hasInvitationExpired: () => import_chunk_PT5LWMPA.hasInvitationExpired,
+  mapFeedIndexesToTimeframe: () => import_chunk_PT5LWMPA.mapFeedIndexesToTimeframe,
+  mapTimeframeToFeedIndexes: () => import_chunk_PT5LWMPA.mapTimeframeToFeedIndexes,
+  startAfter: () => import_chunk_PT5LWMPA.startAfter,
+  valueEncoding: () => import_chunk_PT5LWMPA.valueEncoding
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_RH6TDRML = require("./chunk-RH6TDRML.cjs");
-var import_async = require("@dxos/async");
-var import_automerge = require("@dxos/automerge/automerge");
-var import_automerge_repo = require("@dxos/automerge/automerge-repo");
-var import_context = require("@dxos/context");
-var import_invariant = require("@dxos/invariant");
-var import_keys = require("@dxos/keys");
-var import_log = require("@dxos/log");
-var import_protocols = require("@dxos/protocols");
-var import_tracing = require("@dxos/tracing");
-var import_util = require("@dxos/util");
-var import_async2 = require("@dxos/async");
-var import_automerge_repo2 = require("@dxos/automerge/automerge-repo");
-var import_context2 = require("@dxos/context");
-var import_invariant2 = require("@dxos/invariant");
-var import_log2 = require("@dxos/log");
-var import_indexing = require("@dxos/indexing");
-var import_context3 = require("@dxos/context");
-var import_invariant3 = require("@dxos/invariant");
-var import_keys2 = require("@dxos/keys");
-var import_log3 = require("@dxos/log");
-var import_util2 = require("@dxos/util");
-var import_automerge_repo3 = require("@dxos/automerge/automerge-repo");
-var import_context4 = require("@dxos/context");
-var import_invariant4 = require("@dxos/invariant");
-var import_log4 = require("@dxos/log");
-var import_teleport_extension_automerge_replicator = require("@dxos/teleport-extension-automerge-replicator");
-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_file = "/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_context2.LifecycleState.CLOSED;
-    this._connected = new import_async2.Trigger();
-  }
-  connect(peerId, peerMetadata) {
-    this.peerId = peerId;
-    this.peerMetadata = peerMetadata;
-    this._connected.wake();
-  }
-  send(message) {
-    const connectionEntry = this._connections.get(message.targetId);
-    if (!connectionEntry) {
-      throw new Error("Connection not found.");
-    }
-    connectionEntry.writer.write(message).catch((err) => {
-      if (connectionEntry.isOpen) {
-        import_log2.log.catch(err, void 0, {
-          F: __dxlog_file,
-          L: 49,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    });
-  }
-  disconnect() {
-  }
-  async open() {
-    if (this._lifecycleState === import_context2.LifecycleState.OPEN) {
-      return;
-    }
-    this._lifecycleState = import_context2.LifecycleState.OPEN;
-    (0, import_log2.log)("emit ready", void 0, {
-      F: __dxlog_file,
-      L: 65,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.emit("ready", {
-      network: this
-    });
-  }
-  async close() {
-    if (this._lifecycleState === import_context2.LifecycleState.CLOSED) {
-      return this;
-    }
-    for (const replicator of this._replicators) {
-      await replicator.disconnect();
-    }
-    this._replicators.clear();
-    this._lifecycleState = import_context2.LifecycleState.CLOSED;
-  }
-  async whenConnected() {
-    await this._connected.wait({
-      timeout: 1e4
-    });
-  }
-  async addReplicator(replicator) {
-    (0, import_invariant2.invariant)(this._lifecycleState === import_context2.LifecycleState.OPEN, void 0, {
-      F: __dxlog_file,
-      L: 91,
-      S: this,
-      A: [
-        "this._lifecycleState === LifecycleState.OPEN",
-        ""
-      ]
-    });
-    (0, import_invariant2.invariant)(this.peerId, void 0, {
-      F: __dxlog_file,
-      L: 92,
-      S: this,
-      A: [
-        "this.peerId",
-        ""
-      ]
-    });
-    (0, import_invariant2.invariant)(!this._replicators.has(replicator), void 0, {
-      F: __dxlog_file,
-      L: 93,
-      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),
-      getContainingSpaceForDocument: this._params.getContainingSpaceForDocument
-    });
-  }
-  async removeReplicator(replicator) {
-    (0, import_invariant2.invariant)(this._lifecycleState === import_context2.LifecycleState.OPEN, void 0, {
-      F: __dxlog_file,
-      L: 107,
-      S: this,
-      A: [
-        "this._lifecycleState === LifecycleState.OPEN",
-        ""
-      ]
-    });
-    (0, import_invariant2.invariant)(this._replicators.has(replicator), void 0, {
-      F: __dxlog_file,
-      L: 108,
-      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);
-  }
-  _onConnectionOpen(connection) {
-    (0, import_log2.log)("Connection opened", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 123,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_invariant2.invariant)(!this._connections.has(connection.peerId), void 0, {
-      F: __dxlog_file,
-      L: 124,
-      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.emit("message", value);
-        }
-      } catch (err) {
-        if (connectionEntry.isOpen) {
-          import_log2.log.catch(err, void 0, {
-            F: __dxlog_file,
-            L: 143,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        }
-      }
-    });
-    (0, import_log2.log)("emit peer-candidate", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 148,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._emitPeerCandidate(connection);
-  }
-  /**
-  * 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_log2.log)("Connection auth scope changed", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 157,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const entry = this._connections.get(connection.peerId);
-    (0, import_invariant2.invariant)(entry, void 0, {
-      F: __dxlog_file,
-      L: 159,
-      S: this,
-      A: [
-        "entry",
-        ""
-      ]
-    });
-    this.emit("peer-disconnected", {
-      peerId: connection.peerId
-    });
-    this._emitPeerCandidate(connection);
-  }
-  _onConnectionClosed(connection) {
-    (0, import_log2.log)("Connection closed", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 165,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const entry = this._connections.get(connection.peerId);
-    (0, import_invariant2.invariant)(entry, void 0, {
-      F: __dxlog_file,
-      L: 167,
-      S: this,
-      A: [
-        "entry",
-        ""
-      ]
-    });
-    entry.isOpen = false;
-    this.emit("peer-disconnected", {
-      peerId: connection.peerId
-    });
-    void entry.reader.cancel().catch((err) => import_log2.log.catch(err, void 0, {
-      F: __dxlog_file,
-      L: 172,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-    void entry.writer.abort().catch((err) => import_log2.log.catch(err, void 0, {
-      F: __dxlog_file,
-      L: 173,
-      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_async2.synchronized
-], EchoNetworkAdapter.prototype, "open", null);
-_ts_decorate([
-  import_async2.synchronized
-], EchoNetworkAdapter.prototype, "close", null);
-_ts_decorate([
-  import_async2.synchronized
-], EchoNetworkAdapter.prototype, "addReplicator", null);
-_ts_decorate([
-  import_async2.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
-    });
-  }
-  async getHeads(documentId) {
-    try {
-      return await this._db.get(documentId, {
-        keyEncoding: "utf8",
-        valueEncoding: import_indexing.headsEncoding
-      });
-    } catch (err) {
-      if (err.notFound) {
-        return void 0;
-      }
-      throw err;
-    }
-  }
-};
-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;
-      }
-      return await this._params.db.get(keyArray, {
-        ...encodingOptions
-      });
-    } 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 batch = this._params.db.batch();
-    await this._params.callbacks?.beforeSave?.({
-      path: keyArray,
-      batch
-    });
-    batch.put(keyArray, Buffer.from(binary), {
-      ...encodingOptions
-    });
-    await batch.write();
-    await this._params.callbacks?.afterSave?.(keyArray);
-  }
-  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 result = [];
-    for await (const [key, value] of this._params.db.iterator({
-      gte: keyPrefix,
-      lte: [
-        ...keyPrefix,
-        "\uFFFF"
-      ],
-      ...encodingOptions
-    })) {
-      result.push({
-        key,
-        data: value
-      });
-    }
-    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";
-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_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
-var AutomergeHost = class extends import_context.Resource {
-  constructor({ db, indexMetadataStore }) {
-    super();
-    this._echoNetworkAdapter = new EchoNetworkAdapter({
-      getContainingSpaceForDocument: this._getContainingSpaceForDocument.bind(this)
-    });
-    this._db = db;
-    this._storage = new LevelDBStorageAdapter({
-      db: db.sublevel("automerge"),
-      callbacks: {
-        beforeSave: async (params) => this._beforeSave(params),
-        afterSave: async () => this._afterSave()
-      }
-    });
-    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
-      ]
-    });
-    await this._echoNetworkAdapter.open();
-    await this._echoNetworkAdapter.whenConnected();
-  }
-  async _close() {
-    await this._storage.close?.();
-    await this._echoNetworkAdapter.close();
-    await this._ctx.dispose();
-  }
-  /**
-  * @deprecated To be abstracted away.
-  */
-  get repo() {
-    return this._repo;
-  }
-  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_context.cancelWithContext)(ctx, handle.whenReady());
-      } else {
-        await (0, import_context.cancelWithContext)(ctx, (0, import_async.asyncTimeout)(handle.whenReady(), opts.timeout));
-      }
-    }
-    return handle;
-  }
-  /**
-  * Create new persisted document.
-  */
-  createDoc(initialValue, opts) {
-    if (opts?.preserveHistory) {
-      if (!(0, import_automerge.isAutomerge)(initialValue)) {
-        throw new TypeError("Initial value must be an Automerge document");
-      }
-      return this._repo.import((0, import_automerge.save)(initialValue));
-    } else {
-      return this._repo.create(initialValue);
-    }
-  }
-  async waitUntilHeadsReplicated(heads) {
-    await Promise.all(heads.entries?.map(async ({ documentId, heads: heads2 }) => {
-      if (!heads2 || heads2.length === 0) {
-        return;
-      }
-      const currentHeads = this.getHeads(documentId);
-      if (currentHeads !== null && (0, import_automerge.equals)(currentHeads, heads2)) {
-        return;
-      }
-      const handle = await this.loadDoc(import_context.Context.default(void 0, {
-        F: __dxlog_file2,
-        L: 189
-      }), documentId);
-      await waitForHeads(handle, heads2);
-    }) ?? []);
-    await this._repo.flush(heads.entries?.map((entry) => entry.documentId) ?? []);
-  }
-  async reIndexHeads(documentIds) {
-    for (const documentId of documentIds) {
-      import_log.log.info("re-indexing heads for document", {
-        documentId
-      }, {
-        F: __dxlog_file2,
-        L: 200,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const handle = this._repo.find(documentId);
-      await handle.whenReady([
-        "ready",
-        "requesting"
-      ]);
-      if (handle.inState([
-        "requesting"
-      ])) {
-        import_log.log.warn("document is not available locally, skipping", {
-          documentId
-        }, {
-          F: __dxlog_file2,
-          L: 204,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        continue;
-      }
-      const doc = handle.docSync();
-      (0, import_invariant.invariant)(doc, void 0, {
-        F: __dxlog_file2,
-        L: 209,
-        S: this,
-        A: [
-          "doc",
-          ""
-        ]
-      });
-      const heads = (0, import_automerge.getHeads)(doc);
-      const batch = this._db.batch();
-      this._headsStore.setHeads(documentId, heads, batch);
-      await batch.write();
-    }
-    import_log.log.info("done re-indexing heads", void 0, {
-      F: __dxlog_file2,
-      L: 216,
-      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 spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
-    const heads = (0, import_automerge.getHeads)(doc);
-    this._headsStore.setHeads(handle.documentId, heads, batch);
-    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);
-  }
-  /**
-  * Called by AutomergeStorageAdapter after levelDB batch commit.
-  */
-  async _afterSave() {
-    this._indexMetadataStore.notifyMarkedDirty();
-  }
-  _automergeDocs() {
-    return (0, import_util.mapValues)(this._repo.handles, (handle) => ({
-      state: handle.state,
-      hasDoc: !!handle.docSync(),
-      heads: handle.docSync() ? import_automerge.next.getHeads(handle.docSync()) : null,
-      data: handle.docSync() && (0, import_util.mapValues)(handle.docSync(), (value, key) => {
-        try {
-          switch (key) {
-            case "access":
-            case "links":
-              return value;
-            case "objects":
-              return Object.keys(value);
-            default:
-              return `${value}`;
-          }
-        } catch (err) {
-          return `${err}`;
-        }
-      })
-    }));
-  }
-  _automergePeers() {
-    return this._repo.peers;
-  }
-  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(documentId) {
-    const handle = this._repo.handles[documentId];
-    if (handle) {
-      const doc = handle.docSync();
-      if (!doc) {
-        return void 0;
-      }
-      return (0, import_automerge.getHeads)(doc);
-    } else {
-      return this._headsStore.getHeads(documentId);
-    }
-  }
-};
-_ts_decorate2([
-  import_tracing.trace.info()
-], AutomergeHost.prototype, "_peerId", void 0);
-_ts_decorate2([
-  import_tracing.trace.info({
-    depth: null
-  })
-], AutomergeHost.prototype, "_automergeDocs", null);
-_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_async.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_automerge.getBackend)(doc).getChangeByHash(changeHash);
-};
-var __dxlog_file3 = "/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_context4.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_invariant4.invariant)(this._isEnabled, "Writing to a disabled connection", {
-          F: __dxlog_file3,
-          L: 47,
-          S: this,
-          A: [
-            "this._isEnabled",
-            "'Writing to a disabled connection'"
-          ]
-        });
-        try {
-          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_log4.log)("onStartReplication", {
-            id: info.id,
-            thisPeerId: this.peerId,
-            remotePeerId: remotePeerId.toHex()
-          }, {
-            F: __dxlog_file3,
-            L: 81,
-            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_invariant4.invariant)(this._remotePeerId != null, "Remote peer has not connected yet.", {
-      F: __dxlog_file3,
-      L: 107,
-      S: this,
-      A: [
-        "this._remotePeerId != null",
-        "'Remote peer has not connected yet.'"
-      ]
-    });
-    return this._remotePeerId;
-  }
-  async shouldAdvertise(params) {
-    return this._params.shouldAdvertise(params);
-  }
-  /**
-  * Start exchanging messages with the remote peer.
-  * Call after the remote peer has connected.
-  */
-  enable() {
-    (0, import_invariant4.invariant)(this._remotePeerId != null, "Remote peer has not connected yet.", {
-      F: __dxlog_file3,
-      L: 120,
-      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 __dxlog_file4 = "/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 = new import_util2.ComplexMap(import_keys2.PublicKey.hash);
-    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_invariant3.invariant)(this._context, void 0, {
-      F: __dxlog_file4,
-      L: 54,
-      S: this,
-      A: [
-        "this._context",
-        ""
-      ]
-    });
-    const connection = new MeshReplicatorConnection({
-      ownPeerId: this._context.peerId,
-      replicatorFactory: extensionFactory,
-      onRemoteConnected: async () => {
-        (0, import_log3.log)("onRemoteConnected", {
-          peerId: connection.peerId
-        }, {
-          F: __dxlog_file4,
-          L: 60,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        (0, import_invariant3.invariant)(this._context, void 0, {
-          F: __dxlog_file4,
-          L: 61,
-          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_log3.log)("onRemoteDisconnected", {
-          peerId: connection.peerId
-        }, {
-          F: __dxlog_file4,
-          L: 72,
-          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_log3.log)("shouldAdvertise", {
-          peerId: connection.peerId,
-          documentId: params.documentId
-        }, {
-          F: __dxlog_file4,
-          L: 79,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        (0, import_invariant3.invariant)(this._context, void 0, {
-          F: __dxlog_file4,
-          L: 80,
-          S: this,
-          A: [
-            "this._context",
-            ""
-          ]
-        });
-        try {
-          const spaceKey = await this._context.getContainingSpaceForDocument(params.documentId);
-          if (!spaceKey) {
-            (0, import_log3.log)("space key not found for share policy check", {
-              peerId: connection.peerId,
-              documentId: params.documentId
-            }, {
-              F: __dxlog_file4,
-              L: 84,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return false;
-          }
-          const authorizedDevices = this._authorizedDevices.get(spaceKey);
-          if (!connection.remoteDeviceKey) {
-            (0, import_log3.log)("device key not found for share policy check", {
-              peerId: connection.peerId,
-              documentId: params.documentId
-            }, {
-              F: __dxlog_file4,
-              L: 94,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return false;
-          }
-          const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
-          (0, import_log3.log)("share policy check", {
-            localPeer: this._context.peerId,
-            remotePeer: connection.peerId,
-            documentId: params.documentId,
-            deviceKey: connection.remoteDeviceKey,
-            spaceKey,
-            isAuthorized
-          }, {
-            F: __dxlog_file4,
-            L: 102,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          return isAuthorized;
-        } catch (err) {
-          import_log3.log.catch(err, void 0, {
-            F: __dxlog_file4,
-            L: 112,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          return false;
-        }
-      }
-    });
-    this._connections.add(connection);
-    return connection.replicatorExtension;
-  }
-  authorizeDevice(spaceKey, deviceKey) {
-    (0, import_log3.log)("authorizeDevice", {
-      spaceKey,
-      deviceKey
-    }, {
-      F: __dxlog_file4,
-      L: 123,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    (0, import_util2.defaultMap)(this._authorizedDevices, spaceKey, () => new import_util2.ComplexSet(import_keys2.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);
-        }
-      }
-    }
-  }
-};
+var import_chunk_PT5LWMPA = require("./chunk-PT5LWMPA.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthExtension,
@@ -1101,7 +79,10 @@ var MeshEchoReplicator = class {
   codec,
   createIdFromSpaceKey,
   createMappedFeedWriter,
+  deriveCollectionIdFromSpaceId,
+  diffCollectionState,
   encodingOptions,
+  getSpaceIdFromCollectionId,
   getSpaceKeyFromDoc,
   hasInvitationExpired,
   mapFeedIndexesToTimeframe,