@dxos/echo-pipeline 0.6.2 → 0.6.3-main.40d1cec

package/dist/lib/browser/{chunk-UJQ5VS5V.mjs → chunk-PEE7MYCZ.mjs}

@@ -262,111 +262,276 @@ var DocumentsSynchronizer = class extends Resource {
   }
 };
 
-// packages/core/echo/echo-pipeline/src/db-host/data-service.ts
-import { Stream } from "@dxos/codec-protobuf";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/data-service.ts";
-var DataServiceImpl = class {
+// packages/core/echo/echo-pipeline/src/automerge/collection-synchronizer.ts
+import { asyncReturn, Event, scheduleTask, scheduleTaskInterval } from "@dxos/async";
+import { next as am } from "@dxos/automerge/automerge";
+import { Resource as Resource2 } from "@dxos/context";
+import { defaultMap } from "@dxos/util";
+var MIN_QUERY_INTERVAL = 5e3;
+var POLL_INTERVAL = 3e4;
+var CollectionSynchronizer = class extends Resource2 {
   constructor(params) {
+    super();
     /**
-    * Map of subscriptions.
-    * subscriptionId -> DocumentsSynchronizer
+    * CollectionId -> State.
     */
-    this._subscriptions = /* @__PURE__ */ new Map();
-    this._automergeHost = params.automergeHost;
-    this._updateIndexes = params.updateIndexes;
+    this._perCollectionStates = /* @__PURE__ */ new Map();
+    this._connectedPeers = /* @__PURE__ */ new Set();
+    this.remoteStateUpdated = new Event();
+    this._sendCollectionState = params.sendCollectionState;
+    this._queryCollectionState = params.queryCollectionState;
+    this._shouldSyncCollection = params.shouldSyncCollection;
   }
-  subscribe(request) {
-    return new Stream(({ next, ready }) => {
-      const synchronizer = new DocumentsSynchronizer({
-        repo: this._automergeHost.repo,
-        sendUpdates: (updates) => next(updates)
-      });
-      synchronizer.open().then(() => {
-        this._subscriptions.set(request.subscriptionId, synchronizer);
-        ready();
-      }).catch((err) => log2.catch(err, void 0, {
-        F: __dxlog_file3,
-        L: 62,
-        S: this,
-        C: (f, a) => f(...a)
-      }));
-      return () => synchronizer.close();
+  async _open(ctx) {
+    scheduleTaskInterval(this._ctx, async () => {
+      for (const collectionId of this._perCollectionStates.keys()) {
+        this.refreshCollection(collectionId);
+        await asyncReturn();
+      }
+    }, POLL_INTERVAL);
+  }
+  getRegisteredCollectionIds() {
+    return [
+      ...this._perCollectionStates.keys()
+    ];
+  }
+  getLocalCollectionState(collectionId) {
+    return this._getPerCollectionState(collectionId).localState;
+  }
+  setLocalCollectionState(collectionId, state) {
+    this._getPerCollectionState(collectionId).localState = state;
+    queueMicrotask(async () => {
+      if (!this._ctx.disposed) {
+        this._refreshInterestedPeers(collectionId);
+        this.refreshCollection(collectionId);
+      }
     });
   }
-  async updateSubscription(request) {
-    const synchronizer = this._subscriptions.get(request.subscriptionId);
-    invariant3(synchronizer, "Subscription not found", {
-      F: __dxlog_file3,
-      L: 69,
-      S: this,
-      A: [
-        "synchronizer",
-        "'Subscription not found'"
-      ]
+  getRemoteCollectionStates(collectionId) {
+    return this._getPerCollectionState(collectionId).remoteStates;
+  }
+  refreshCollection(collectionId) {
+    let scheduleAnotherRefresh = false;
+    const state = this._getPerCollectionState(collectionId);
+    for (const peerId of this._connectedPeers) {
+      if (state.interestedPeers.has(peerId)) {
+        const lastQueried = state.lastQueried.get(peerId) ?? 0;
+        if (Date.now() - lastQueried > MIN_QUERY_INTERVAL) {
+          state.lastQueried.set(peerId, Date.now());
+          this._queryCollectionState(collectionId, peerId);
+        } else {
+          scheduleAnotherRefresh = true;
+        }
+      }
+    }
+    if (scheduleAnotherRefresh) {
+      scheduleTask(this._ctx, () => this.refreshCollection(collectionId), MIN_QUERY_INTERVAL);
+    }
+  }
+  /**
+  * Callback when a connection to a peer is established.
+  */
+  onConnectionOpen(peerId) {
+    this._connectedPeers.add(peerId);
+    queueMicrotask(async () => {
+      if (this._ctx.disposed) {
+        return;
+      }
+      for (const [collectionId, state] of this._perCollectionStates.entries()) {
+        if (this._shouldSyncCollection(collectionId, peerId)) {
+          state.interestedPeers.add(peerId);
+          state.lastQueried.set(peerId, Date.now());
+          this._queryCollectionState(collectionId, peerId);
+        }
+      }
     });
-    if (request.addIds?.length) {
-      await synchronizer.addDocuments(request.addIds);
+  }
+  /**
+  * 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);
     }
-    if (request.removeIds?.length) {
-      await synchronizer.removeDocuments(request.removeIds);
+  }
+  /**
+  * 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);
     }
   }
-  async update(request) {
-    if (!request.updates) {
-      return;
+  /**
+  * Callback when a peer sends the state of a collection.
+  */
+  onRemoteStateReceived(collectionId, peerId, state) {
+    const perCollectionState = this._getPerCollectionState(collectionId);
+    perCollectionState.remoteStates.set(peerId, state);
+    this.remoteStateUpdated.emit({
+      peerId,
+      collectionId
+    });
+  }
+  _getPerCollectionState(collectionId) {
+    return defaultMap(this._perCollectionStates, collectionId, () => ({
+      localState: void 0,
+      remoteStates: /* @__PURE__ */ new Map(),
+      interestedPeers: /* @__PURE__ */ new Set(),
+      lastQueried: /* @__PURE__ */ new Map()
+    }));
+  }
+  _refreshInterestedPeers(collectionId) {
+    for (const peerId of this._connectedPeers) {
+      if (this._shouldSyncCollection(collectionId, peerId)) {
+        this._getPerCollectionState(collectionId).interestedPeers.add(peerId);
+      } else {
+        this._getPerCollectionState(collectionId).interestedPeers.delete(peerId);
+      }
     }
-    const synchronizer = this._subscriptions.get(request.subscriptionId);
-    invariant3(synchronizer, "Subscription not found", {
-      F: __dxlog_file3,
-      L: 84,
-      S: this,
-      A: [
-        "synchronizer",
-        "'Subscription not found'"
-      ]
-    });
-    synchronizer.update(request.updates);
   }
-  async flush(request) {
-    await this._automergeHost.flush(request);
+};
+var diffCollectionState = (local, remote) => {
+  const allDocuments = /* @__PURE__ */ new Set([
+    ...Object.keys(local.documents),
+    ...Object.keys(remote.documents)
+  ]);
+  const different = [];
+  for (const documentId of allDocuments) {
+    if (!local.documents[documentId] || !remote.documents[documentId] || !am.equals(local.documents[documentId], remote.documents[documentId])) {
+      different.push(documentId);
+    }
   }
-  async getDocumentHeads(request) {
-    const entries = await Promise.all(request.documentIds?.map(async (documentId) => {
-      const heads = await this._automergeHost.getHeads(documentId);
-      return {
-        documentId,
-        heads
-      };
-    }) ?? []);
-    return {
-      heads: {
-        entries
+  return {
+    different
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/leveldb-storage-adapter.ts
+import { LifecycleState, Resource as Resource3 } from "@dxos/context";
+var LevelDBStorageAdapter = class extends Resource3 {
+  constructor(_params) {
+    super();
+    this._params = _params;
+  }
+  async load(keyArray) {
+    try {
+      if (this._lifecycleState !== LifecycleState.OPEN) {
+        return void 0;
       }
-    };
+      return await this._params.db.get(keyArray, {
+        ...encodingOptions
+      });
+    } catch (err) {
+      if (isLevelDbNotFoundError(err)) {
+        return void 0;
+      }
+      throw err;
+    }
   }
-  async waitUntilHeadsReplicated(request, options) {
-    await this._automergeHost.waitUntilHeadsReplicated(request.heads);
+  async save(keyArray, binary) {
+    if (this._lifecycleState !== 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 reIndexHeads(request, options) {
-    await this._automergeHost.reIndexHeads(request.documentIds ?? []);
+  async remove(keyArray) {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
+      return void 0;
+    }
+    await this._params.db.del(keyArray, {
+      ...encodingOptions
+    });
   }
-  async updateIndexes() {
-    await this._updateIndexes();
+  async loadRange(keyPrefix) {
+    if (this._lifecycleState !== 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 !== LifecycleState.OPEN) {
+      return void 0;
+    }
+    const batch = this._params.db.batch();
+    for await (const [key] of this._params.db.iterator({
+      gte: keyPrefix,
+      lte: [
+        ...keyPrefix,
+        "\uFFFF"
+      ],
+      ...encodingOptions
+    })) {
+      batch.del(key, {
+        ...encodingOptions
+      });
+    }
+    await batch.write();
   }
 };
+var keyEncoder = {
+  encode: (key) => Buffer.from(key.map((k) => k.replaceAll("%", "%25").replaceAll("-", "%2D")).join("-")),
+  decode: (key) => Buffer.from(key).toString().split("-").map((k) => k.replaceAll("%2D", "-").replaceAll("%25", "%")),
+  format: "buffer"
+};
+var encodingOptions = {
+  keyEncoding: keyEncoder,
+  valueEncoding: "buffer"
+};
+var isLevelDbNotFoundError = (err) => err.code === "LEVEL_NOT_FOUND";
 
-// packages/core/echo/echo-pipeline/src/metadata/metadata-store.ts
-import CRC32 from "crc-32";
-import { Event, scheduleTaskInterval, synchronized } from "@dxos/async";
-import { Context } from "@dxos/context";
+// packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts
+import { Event as Event2, asyncTimeout } from "@dxos/async";
+import { next as automerge, getBackend, getHeads, isAutomerge, equals as headsEquals, save } from "@dxos/automerge/automerge";
+import { Repo } from "@dxos/automerge/automerge-repo";
+import { Context, Resource as Resource4, cancelWithContext as cancelWithContext2 } from "@dxos/context";
 import { invariant as invariant4 } from "@dxos/invariant";
 import { PublicKey as PublicKey2 } from "@dxos/keys";
 import { log as log3 } from "@dxos/log";
-import { DataCorruptionError, STORAGE_VERSION, schema as schema4 } from "@dxos/protocols";
-import { Invitation, SpaceState } from "@dxos/protocols/proto/dxos/client/services";
-import { ComplexMap, arrayToBuffer, forEachAsync, isNotNullOrUndefined } from "@dxos/util";
+import { objectPointerCodec } from "@dxos/protocols";
+import { trace } from "@dxos/tracing";
+import { mapValues } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts
+import { synchronized, Trigger } from "@dxos/async";
+import { NetworkAdapter } from "@dxos/automerge/automerge-repo";
+import { LifecycleState as LifecycleState2 } from "@dxos/context";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { log as log2 } from "@dxos/log";
+import { nonNullable } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/automerge/network-protocol.ts
+var MESSAGE_TYPE_COLLECTION_QUERY = "collection-query";
+var isCollectionQueryMessage = (message) => message.type === MESSAGE_TYPE_COLLECTION_QUERY;
+var MESSAGE_TYPE_COLLECTION_STATE = "collection-state";
+var isCollectionStateMessage = (message) => message.type === MESSAGE_TYPE_COLLECTION_STATE;
+
+// packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -377,334 +542,348 @@ function _ts_decorate(decorators, target, key, desc) {
         r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/metadata/metadata-store.ts";
-var EXPIRED_INVITATION_CLEANUP_INTERVAL = 60 * 60 * 1e3;
-var emptyEchoMetadata = () => ({
-  version: STORAGE_VERSION,
-  spaces: [],
-  created: /* @__PURE__ */ new Date(),
-  updated: /* @__PURE__ */ new Date()
-});
-var emptyLargeSpaceMetadata = () => ({});
-var EchoMetadata = schema4.getCodecForType("dxos.echo.metadata.EchoMetadata");
-var LargeSpaceMetadata = schema4.getCodecForType("dxos.echo.metadata.LargeSpaceMetadata");
-var MetadataStore = class {
-  constructor(directory) {
-    this._metadata = emptyEchoMetadata();
-    this._spaceLargeMetadata = new ComplexMap(PublicKey2.hash);
-    this._metadataFile = void 0;
-    this.update = new Event();
-    this._invitationCleanupCtx = new Context(void 0, {
-      F: __dxlog_file4,
-      L: 53
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts";
+var EchoNetworkAdapter = class extends NetworkAdapter {
+  constructor(_params) {
+    super();
+    this._params = _params;
+    this._replicators = /* @__PURE__ */ new Set();
+    this._connections = /* @__PURE__ */ new Map();
+    this._lifecycleState = LifecycleState2.CLOSED;
+    this._connected = new 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) {
+        log2.catch(err, void 0, {
+          F: __dxlog_file3,
+          L: 63,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
     });
-    this._directory = directory;
   }
-  get metadata() {
-    return this._metadata;
-  }
-  get version() {
-    return this._metadata.version ?? 0;
-  }
-  /**
-  * Returns a list of currently saved spaces. The list and objects in it can be modified addSpace and
-  * addSpaceFeed functions.
-  */
-  get spaces() {
-    return this._metadata.spaces ?? [];
+  disconnect() {
   }
-  async _readFile(file, codec2) {
-    try {
-      const { size: fileLength } = await file.stat();
-      if (fileLength < 8) {
-        return;
-      }
-      const dataSize = fromBytesInt32(await file.read(0, 4));
-      const checksum = fromBytesInt32(await file.read(4, 4));
-      log3("loaded", {
-        size: dataSize,
-        checksum,
-        name: file.filename
-      }, {
-        F: __dxlog_file4,
-        L: 89,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      if (fileLength < dataSize + 8) {
-        throw new DataCorruptionError("Metadata size is smaller than expected.", {
-          fileLength,
-          dataSize
-        });
-      }
-      const data = await file.read(8, dataSize);
-      const calculatedChecksum = CRC32.buf(data);
-      if (calculatedChecksum !== checksum) {
-        throw new DataCorruptionError("Metadata checksum is invalid.");
-      }
-      return codec2.decode(data);
-    } finally {
-      await file.close();
+  async open() {
+    if (this._lifecycleState === LifecycleState2.OPEN) {
+      return;
     }
-  }
-  /**
-  * @internal
-  */
-  async _writeFile(file, codec2, data) {
-    const encoded = arrayToBuffer(codec2.encode(data));
-    const checksum = CRC32.buf(encoded);
-    const result = Buffer.alloc(8 + encoded.length);
-    result.writeInt32LE(encoded.length, 0);
-    result.writeInt32LE(checksum, 4);
-    encoded.copy(result, 8);
-    await file.write(0, result);
-    log3("saved", {
-      size: encoded.length,
-      checksum
-    }, {
-      F: __dxlog_file4,
-      L: 124,
+    this._lifecycleState = LifecycleState2.OPEN;
+    log2("emit ready", void 0, {
+      F: __dxlog_file3,
+      L: 79,
       S: this,
       C: (f, a) => f(...a)
     });
+    this.emit("ready", {
+      network: this
+    });
   }
   async close() {
-    await this._invitationCleanupCtx.dispose();
-    await this.flush();
-    await this._metadataFile?.close();
-    this._metadataFile = void 0;
-    this._metadata = emptyEchoMetadata();
-    this._spaceLargeMetadata.clear();
-  }
-  /**
-  * Loads metadata from persistent storage.
-  */
-  async load() {
-    if (!this._metadataFile || this._metadataFile.closed) {
-      this._metadataFile = this._directory.getOrCreateFile("EchoMetadata");
+    if (this._lifecycleState === LifecycleState2.CLOSED) {
+      return this;
     }
-    try {
-      const metadata = await this._readFile(this._metadataFile, EchoMetadata);
-      if (metadata) {
-        this._metadata = metadata;
-      }
-      this._metadata.spaces?.forEach((space) => {
-        space.state ??= SpaceState.ACTIVE;
-      });
-    } catch (err) {
-      log3.error("failed to load metadata", {
-        err
-      }, {
-        F: __dxlog_file4,
-        L: 156,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      this._metadata = emptyEchoMetadata();
+    for (const replicator of this._replicators) {
+      await replicator.disconnect();
     }
-    await forEachAsync([
-      this._metadata.identity?.haloSpace.key,
-      ...this._metadata.spaces?.map((space) => space.key) ?? []
-    ].filter(isNotNullOrUndefined), async (key) => {
-      try {
-        await this._loadSpaceLargeMetadata(key);
-      } catch (err) {
-        log3.error("failed to load space large metadata", {
-          err
-        }, {
-          F: __dxlog_file4,
-          L: 168,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    });
-    scheduleTaskInterval(this._invitationCleanupCtx, async () => {
-      for (const invitation of this._metadata.invitations ?? []) {
-        if (hasInvitationExpired(invitation) || isLegacyInvitationFormat(invitation)) {
-          await this.removeInvitation(invitation.invitationId);
-        }
-      }
-    }, EXPIRED_INVITATION_CLEANUP_INTERVAL);
+    this._replicators.clear();
+    this._lifecycleState = LifecycleState2.CLOSED;
   }
-  async _save() {
-    const data = {
-      ...this._metadata,
-      version: STORAGE_VERSION,
-      created: this._metadata.created ?? /* @__PURE__ */ new Date(),
-      updated: /* @__PURE__ */ new Date()
-    };
-    this.update.emit(data);
-    const file = this._directory.getOrCreateFile("EchoMetadata");
-    await this._writeFile(file, EchoMetadata, data);
+  async whenConnected() {
+    await this._connected.wait({
+      timeout: 1e4
+    });
   }
-  async _loadSpaceLargeMetadata(key) {
-    const file = this._directory.getOrCreateFile(`space_${key.toHex()}_large`);
-    try {
-      const metadata = await this._readFile(file, LargeSpaceMetadata);
-      if (metadata) {
-        this._spaceLargeMetadata.set(key, metadata);
-      }
-    } catch (err) {
-      log3.error("failed to load space large metadata", {
-        err
-      }, {
-        F: __dxlog_file4,
-        L: 210,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
+  async addReplicator(replicator) {
+    invariant3(this._lifecycleState === LifecycleState2.OPEN, void 0, {
+      F: __dxlog_file3,
+      L: 105,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    invariant3(this.peerId, void 0, {
+      F: __dxlog_file3,
+      L: 106,
+      S: this,
+      A: [
+        "this.peerId",
+        ""
+      ]
+    });
+    invariant3(!this._replicators.has(replicator), void 0, {
+      F: __dxlog_file3,
+      L: 107,
+      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 _saveSpaceLargeMetadata(key) {
-    const data = this._getLargeSpaceMetadata(key);
-    const file = this._directory.getOrCreateFile(`space_${key.toHex()}_large`);
-    await this._writeFile(file, LargeSpaceMetadata, data);
+  async removeReplicator(replicator) {
+    invariant3(this._lifecycleState === LifecycleState2.OPEN, void 0, {
+      F: __dxlog_file3,
+      L: 121,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    invariant3(this._replicators.has(replicator), void 0, {
+      F: __dxlog_file3,
+      L: 122,
+      S: this,
+      A: [
+        "this._replicators.has(replicator)",
+        ""
+      ]
+    });
+    await replicator.disconnect();
+    this._replicators.delete(replicator);
   }
-  async flush() {
-    await this._directory.flush();
+  async shouldAdvertise(peerId, params) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      return false;
+    }
+    return connection.connection.shouldAdvertise(params);
   }
-  _getSpace(spaceKey) {
-    if (this._metadata.identity?.haloSpace.key.equals(spaceKey)) {
-      return this._metadata.identity.haloSpace;
+  shouldSyncCollection(peerId, params) {
+    const connection = this._connections.get(peerId);
+    if (!connection) {
+      return false;
     }
-    const space = this.spaces.find((space2) => space2.key === spaceKey);
-    invariant4(space, "Space not found", {
-      F: __dxlog_file4,
-      L: 232,
+    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);
+  }
+  // TODO(dmaretskyi): Remove.
+  getPeersInterestedInCollection(collectionId) {
+    return Array.from(this._connections.values()).map((connection) => {
+      return connection.connection.shouldSyncCollection({
+        collectionId
+      }) ? connection.connection.peerId : null;
+    }).filter(nonNullable);
+  }
+  _onConnectionOpen(connection) {
+    log2("Connection opened", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 178,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    invariant3(!this._connections.has(connection.peerId), void 0, {
+      F: __dxlog_file3,
+      L: 179,
       S: this,
       A: [
-        "space",
-        "'Space not found'"
+        "!this._connections.has(connection.peerId as PeerId)",
+        ""
       ]
     });
-    return space;
+    const reader = connection.readable.getReader();
+    const writer = connection.writable.getWriter();
+    const connectionEntry = {
+      connection,
+      reader,
+      writer,
+      isOpen: true
+    };
+    this._connections.set(connection.peerId, connectionEntry);
+    queueMicrotask(async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          this._onMessage(value);
+        }
+      } catch (err) {
+        if (connectionEntry.isOpen) {
+          log2.catch(err, void 0, {
+            F: __dxlog_file3,
+            L: 198,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    log2("emit peer-candidate", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 203,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._emitPeerCandidate(connection);
   }
-  _getLargeSpaceMetadata(key) {
-    let entry = this._spaceLargeMetadata.get(key);
-    if (entry) {
-      return entry;
+  _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);
     }
-    entry = emptyLargeSpaceMetadata();
-    this._spaceLargeMetadata.set(key, entry);
-    return entry;
   }
   /**
-  * Clears storage - doesn't work for now.
+  * 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
   */
-  async clear() {
-    log3("clearing all metadata", void 0, {
-      F: __dxlog_file4,
-      L: 251,
+  _onConnectionAuthScopeChanged(connection) {
+    log2("Connection auth scope changed", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 222,
       S: this,
       C: (f, a) => f(...a)
     });
-    await this._directory.delete();
-    this._metadata = emptyEchoMetadata();
-  }
-  getIdentityRecord() {
-    return this._metadata.identity;
-  }
-  async setIdentityRecord(record) {
-    invariant4(!this._metadata.identity, "Cannot overwrite existing identity in metadata", {
-      F: __dxlog_file4,
-      L: 261,
+    const entry = this._connections.get(connection.peerId);
+    invariant3(entry, void 0, {
+      F: __dxlog_file3,
+      L: 224,
       S: this,
       A: [
-        "!this._metadata.identity",
-        "'Cannot overwrite existing identity in metadata'"
+        "entry",
+        ""
       ]
     });
-    this._metadata.identity = record;
-    await this._save();
-    await this.flush();
-  }
-  getInvitations() {
-    return this._metadata.invitations ?? [];
-  }
-  async addInvitation(invitation) {
-    if (this._metadata.invitations?.find((i) => i.invitationId === invitation.invitationId)) {
-      return;
-    }
-    (this._metadata.invitations ??= []).push(invitation);
-    await this._save();
-    await this.flush();
-  }
-  async removeInvitation(invitationId) {
-    this._metadata.invitations = (this._metadata.invitations ?? []).filter((i) => i.invitationId !== invitationId);
-    await this._save();
-    await this.flush();
+    this.emit("peer-disconnected", {
+      peerId: connection.peerId
+    });
+    this._emitPeerCandidate(connection);
   }
-  async addSpace(record) {
-    invariant4(!(this._metadata.spaces ?? []).find((space) => space.key === record.key), "Cannot overwrite existing space in metadata", {
-      F: __dxlog_file4,
-      L: 289,
+  _onConnectionClosed(connection) {
+    log2("Connection closed", {
+      peerId: connection.peerId
+    }, {
+      F: __dxlog_file3,
+      L: 230,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const entry = this._connections.get(connection.peerId);
+    invariant3(entry, void 0, {
+      F: __dxlog_file3,
+      L: 232,
       S: this,
       A: [
-        "!(this._metadata.spaces ?? []).find((space) => space.key === record.key)",
-        "'Cannot overwrite existing space in metadata'"
+        "entry",
+        ""
       ]
     });
-    (this._metadata.spaces ??= []).push(record);
-    await this._save();
-    await this.flush();
-  }
-  async setSpaceDataLatestTimeframe(spaceKey, timeframe) {
-    this._getSpace(spaceKey).dataTimeframe = timeframe;
-    await this._save();
-  }
-  async setSpaceControlLatestTimeframe(spaceKey, timeframe) {
-    this._getSpace(spaceKey).controlTimeframe = timeframe;
-    await this._save();
-    await this.flush();
-  }
-  async setCache(spaceKey, cache) {
-    this._getSpace(spaceKey).cache = cache;
-    await this._save();
-  }
-  async setWritableFeedKeys(spaceKey, controlFeedKey, dataFeedKey) {
-    const space = this._getSpace(spaceKey);
-    space.controlFeedKey = controlFeedKey;
-    space.dataFeedKey = dataFeedKey;
-    await this._save();
-    await this.flush();
-  }
-  async setSpaceState(spaceKey, state) {
-    this._getSpace(spaceKey).state = state;
-    await this._save();
-    await this.flush();
-  }
-  getSpaceControlPipelineSnapshot(spaceKey) {
-    return this._getLargeSpaceMetadata(spaceKey).controlPipelineSnapshot;
+    entry.isOpen = false;
+    this.emit("peer-disconnected", {
+      peerId: connection.peerId
+    });
+    void entry.reader.cancel().catch((err) => log2.catch(err, void 0, {
+      F: __dxlog_file3,
+      L: 237,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+    void entry.writer.abort().catch((err) => log2.catch(err, void 0, {
+      F: __dxlog_file3,
+      L: 238,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+    this._connections.delete(connection.peerId);
   }
-  async setSpaceControlPipelineSnapshot(spaceKey, snapshot) {
-    this._getLargeSpaceMetadata(spaceKey).controlPipelineSnapshot = snapshot;
-    await this._saveSpaceLargeMetadata(spaceKey);
-    await this.flush();
+  _emitPeerCandidate(connection) {
+    this.emit("peer-candidate", {
+      peerId: connection.peerId,
+      peerMetadata: createEchoPeerMetadata()
+    });
   }
 };
 _ts_decorate([
   synchronized
-], MetadataStore.prototype, "load", null);
+], EchoNetworkAdapter.prototype, "open", null);
 _ts_decorate([
   synchronized
-], MetadataStore.prototype, "_save", null);
+], EchoNetworkAdapter.prototype, "close", null);
 _ts_decorate([
   synchronized
-], MetadataStore.prototype, "_saveSpaceLargeMetadata", null);
-var fromBytesInt32 = (buf) => buf.readInt32LE(0);
-var hasInvitationExpired = (invitation) => {
-  return Boolean(invitation.created && invitation.lifetime && invitation.lifetime !== 0 && invitation.created.getTime() + invitation.lifetime * 1e3 < Date.now());
-};
-var isLegacyInvitationFormat = (invitation) => {
-  return invitation.type === Invitation.Type.MULTIUSE;
+], EchoNetworkAdapter.prototype, "addReplicator", null);
+_ts_decorate([
+  synchronized
+], EchoNetworkAdapter.prototype, "removeReplicator", null);
+var createEchoPeerMetadata = () => ({
+  // TODO(dmaretskyi): Refactor this.
+  dxos_peerSource: "EchoNetworkAdapter"
+});
+var isEchoPeerMetadata = (metadata) => metadata?.dxos_peerSource === "EchoNetworkAdapter";
+
+// packages/core/echo/echo-pipeline/src/automerge/heads-store.ts
+import { headsEncoding } from "@dxos/indexing";
+var HeadsStore = class {
+  constructor({ db }) {
+    this._db = db;
+  }
+  setHeads(documentId, heads, batch) {
+    batch.put(documentId, heads, {
+      sublevel: this._db,
+      keyEncoding: "utf8",
+      valueEncoding: headsEncoding
+    });
+  }
+  // TODO(dmaretskyi): Make batched.
+  async getHeads(documentIds) {
+    return this._db.getMany(documentIds, {
+      keyEncoding: "utf8",
+      valueEncoding: headsEncoding
+    });
+  }
 };
 
-// packages/core/echo/echo-pipeline/src/pipeline/timeframe-clock.ts
-import { Event as Event2 } from "@dxos/async";
-import { timed } from "@dxos/debug";
-import { log as log4 } from "@dxos/log";
-import { Timeframe } from "@dxos/timeframe";
+// packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -715,241 +894,848 @@ function _ts_decorate2(decorators, target, key, desc) {
         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_file5 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/pipeline/timeframe-clock.ts";
-var mapTimeframeToFeedIndexes = (timeframe) => timeframe.frames().map(([feedKey, index]) => ({
-  feedKey,
-  index
-}));
-var mapFeedIndexesToTimeframe = (indexes) => new Timeframe(indexes.map(({ feedKey, index }) => [
-  feedKey,
-  index
-]));
-var startAfter = (timeframe) => timeframe.frames().map(([feedKey, index]) => ({
-  feedKey,
-  index: index + 1
-}));
-var TimeframeClock = class {
-  constructor(_timeframe = new Timeframe()) {
-    this._timeframe = _timeframe;
-    this.update = new Event2();
-    this._pendingTimeframe = _timeframe;
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
+var AutomergeHost = class extends Resource4 {
+  constructor({ db, indexMetadataStore }) {
+    super();
+    this._echoNetworkAdapter = new EchoNetworkAdapter({
+      getContainingSpaceForDocument: this._getContainingSpaceForDocument.bind(this),
+      onCollectionStateQueried: this._onCollectionStateQueried.bind(this),
+      onCollectionStateReceived: this._onCollectionStateReceived.bind(this)
+    });
+    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)
+      }
+    });
+    this._headsStore = new HeadsStore({
+      db: db.sublevel("heads")
+    });
+    this._indexMetadataStore = indexMetadataStore;
   }
-  /**
-  * Timeframe that was processed by ECHO.
-  */
-  get timeframe() {
-    return this._timeframe;
+  async _open() {
+    this._peerId = `host-${PublicKey2.random().toHex()}`;
+    await this._storage.open?.();
+    this._repo = new Repo({
+      peerId: this._peerId,
+      sharePolicy: this._sharePolicy.bind(this),
+      storage: this._storage,
+      network: [
+        // Upstream swarm.
+        this._echoNetworkAdapter
+      ]
+    });
+    Event2.wrap(this._echoNetworkAdapter, "peer-candidate").on(this._ctx, (e) => this._onPeerConnected(e.peerId));
+    Event2.wrap(this._echoNetworkAdapter, "peer-disconnected").on(this._ctx, (e) => this._onPeerDisconnected(e.peerId));
+    this._collectionSynchronizer.remoteStateUpdated.on(this._ctx, ({ collectionId, peerId }) => {
+      this._onRemoteCollectionStateUpdated(collectionId, peerId);
+    });
+    await this._echoNetworkAdapter.open();
+    await this._collectionSynchronizer.open();
+    await this._echoNetworkAdapter.open();
+    await this._echoNetworkAdapter.whenConnected();
+  }
+  async _close() {
+    await this._collectionSynchronizer.close();
+    await this._storage.close?.();
+    await this._echoNetworkAdapter.close();
+    await this._ctx.dispose();
   }
   /**
-  * Timeframe that is currently being processed by ECHO.
-  * Will be equal to `timeframe` after the processing is complete.
+  * @deprecated To be abstracted away.
   */
-  get pendingTimeframe() {
-    return this._pendingTimeframe;
+  get repo() {
+    return this._repo;
   }
-  setTimeframe(timeframe) {
-    this._timeframe = timeframe;
-    this._pendingTimeframe = timeframe;
-    this.update.emit(this._timeframe);
+  get peerId() {
+    return this._peerId;
   }
-  updatePendingTimeframe(key, seq) {
-    this._pendingTimeframe = Timeframe.merge(this._pendingTimeframe, new Timeframe([
-      [
-        key,
-        seq
-      ]
-    ]));
+  get loadedDocsCount() {
+    return Object.keys(this._repo.handles).length;
   }
-  updateTimeframe() {
-    this._timeframe = this._pendingTimeframe;
-    this.update.emit(this._timeframe);
+  async addReplicator(replicator) {
+    await this._echoNetworkAdapter.addReplicator(replicator);
   }
-  hasGaps(timeframe) {
-    const gaps = Timeframe.dependencies(timeframe, this._timeframe);
-    return !gaps.isEmpty();
+  async removeReplicator(replicator) {
+    await this._echoNetworkAdapter.removeReplicator(replicator);
   }
-  async waitUntilReached(target) {
-    log4("waitUntilReached", {
-      target,
-      current: this._timeframe
-    }, {
-      F: __dxlog_file5,
-      L: 70,
-      S: this,
-      C: (f, a) => f(...a)
+  /**
+  * 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 cancelWithContext2(ctx, handle.whenReady());
+      } else {
+        await cancelWithContext2(ctx, asyncTimeout(handle.whenReady(), opts.timeout));
+      }
+    }
+    return handle;
+  }
+  /**
+  * Create new persisted document.
+  */
+  createDoc(initialValue, opts) {
+    if (opts?.preserveHistory) {
+      if (!isAutomerge(initialValue)) {
+        throw new TypeError("Initial value must be an Automerge document");
+      }
+      return this._repo.import(save(initialValue));
+    } else {
+      return this._repo.create(initialValue);
+    }
+  }
+  async waitUntilHeadsReplicated(heads) {
+    const entries = heads.entries;
+    if (!entries?.length) {
+      return;
+    }
+    const documentIds = entries.map((entry) => entry.documentId);
+    const documentHeads = await this.getHeads(documentIds);
+    const headsToWait = entries.filter((entry, index) => {
+      const targetHeads = entry.heads;
+      if (!targetHeads || targetHeads.length === 0) {
+        return false;
+      }
+      const currentHeads = documentHeads[index];
+      return !(currentHeads !== null && headsEquals(currentHeads, targetHeads));
     });
-    await this.update.waitForCondition(() => {
-      log4("check if reached", {
-        target,
-        current: this._timeframe,
-        deps: Timeframe.dependencies(target, this._timeframe)
+    if (headsToWait.length > 0) {
+      await Promise.all(headsToWait.map(async (entry, index) => {
+        const handle = await this.loadDoc(Context.default(void 0, {
+          F: __dxlog_file4,
+          L: 223
+        }), entry.documentId);
+        await waitForHeads(handle, entry.heads);
+      }));
+    }
+    await this._repo.flush(heads.entries?.map((entry) => entry.documentId) ?? []);
+  }
+  async reIndexHeads(documentIds) {
+    for (const documentId of documentIds) {
+      log3.info("re-indexing heads for document", {
+        documentId
       }, {
-        F: __dxlog_file5,
-        L: 72,
+        F: __dxlog_file4,
+        L: 235,
         S: this,
         C: (f, a) => f(...a)
       });
-      return Timeframe.dependencies(target, this._timeframe).isEmpty();
-    });
-  }
-};
-_ts_decorate2([
-  timed(5e3)
-], TimeframeClock.prototype, "waitUntilReached", null);
-
-// packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
-import { Event as Event3, sleepWithContext, synchronized as synchronized2, Trigger } from "@dxos/async";
-import { Context as Context2, rejectOnDispose } from "@dxos/context";
-import { failUndefined } from "@dxos/debug";
-import { FeedSetIterator } from "@dxos/feed-store";
-import { invariant as invariant6 } from "@dxos/invariant";
-import { PublicKey as PublicKey3 } from "@dxos/keys";
-import { log as log6 } from "@dxos/log";
-import { Timeframe as Timeframe2 } from "@dxos/timeframe";
-import { ComplexMap as ComplexMap2 } from "@dxos/util";
-
-// packages/core/echo/echo-pipeline/src/pipeline/message-selector.ts
-import { invariant as invariant5 } from "@dxos/invariant";
-import { log as log5 } from "@dxos/log";
-var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/pipeline/message-selector.ts";
-var createMessageSelector = (timeframeClock) => {
-  return (messages) => {
-    for (let i = 0; i < messages.length; i++) {
-      const { data: { timeframe } } = messages[i];
-      invariant5(timeframe, void 0, {
-        F: __dxlog_file6,
-        L: 25,
-        S: void 0,
+      const handle = this._repo.find(documentId);
+      await handle.whenReady([
+        "ready",
+        "requesting"
+      ]);
+      if (handle.inState([
+        "requesting"
+      ])) {
+        log3.warn("document is not available locally, skipping", {
+          documentId
+        }, {
+          F: __dxlog_file4,
+          L: 239,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const doc = handle.docSync();
+      invariant4(doc, void 0, {
+        F: __dxlog_file4,
+        L: 244,
+        S: this,
         A: [
-          "timeframe",
+          "doc",
           ""
         ]
       });
-      if (!timeframeClock.hasGaps(timeframe)) {
-        return i;
-      }
+      const heads = getHeads(doc);
+      const batch = this._db.batch();
+      this._headsStore.setHeads(documentId, heads, batch);
+      await batch.write();
     }
-    log5("Skipping...", void 0, {
-      F: __dxlog_file6,
-      L: 33,
-      S: void 0,
+    log3.info("done re-indexing heads", void 0, {
+      F: __dxlog_file4,
+      L: 251,
+      S: this,
       C: (f, a) => f(...a)
     });
-  };
-};
-
-// packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
-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 __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts";
-var PipelineState = class {
-  constructor(_feeds, _timeframeClock) {
-    this._feeds = _feeds;
-    this._timeframeClock = _timeframeClock;
-    this._ctx = new Context2(void 0, {
-      F: __dxlog_file7,
-      L: 41
-    });
-    this.timeframeUpdate = this._timeframeClock.update;
-    this.stalled = new Event3();
-    this._startTimeframe = new Timeframe2();
-    this._reachedTarget = false;
+  }
+  // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
+  // Hosts, running in the worker, don't share documents unless requested by other peers.
+  // NOTE: If both peers return sharePolicy=false the replication will not happen
+  // https://github.com/automerge/automerge-repo/pull/292
+  async _sharePolicy(peerId, documentId) {
+    if (peerId.startsWith("client-")) {
+      return false;
+    }
+    if (!documentId) {
+      return false;
+    }
+    const peerMetadata = this.repo.peerMetadataByPeerId[peerId];
+    if (isEchoPeerMetadata(peerMetadata)) {
+      return this._echoNetworkAdapter.shouldAdvertise(peerId, {
+        documentId
+      });
+    }
+    return false;
+  }
+  async _beforeSave({ path, batch }) {
+    const handle = this._repo.handles[path[0]];
+    if (!handle) {
+      return;
+    }
+    const doc = handle.docSync();
+    if (!doc) {
+      return;
+    }
+    const heads = getHeads(doc);
+    this._headsStore.setHeads(handle.documentId, heads, batch);
+    const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+    const objectIds = Object.keys(doc.objects ?? {});
+    const encodedIds = objectIds.map((objectId) => objectPointerCodec.encode({
+      documentId: handle.documentId,
+      objectId,
+      spaceKey
+    }));
+    const idToLastHash = new Map(encodedIds.map((id) => [
+      id,
+      heads
+    ]));
+    this._indexMetadataStore.markDirty(idToLastHash, batch);
+  }
+  _shouldSyncCollection(collectionId, peerId) {
+    const peerMetadata = this._repo.peerMetadataByPeerId[peerId];
+    if (isEchoPeerMetadata(peerMetadata)) {
+      return this._echoNetworkAdapter.shouldSyncCollection(peerId, {
+        collectionId
+      });
+    }
+    return false;
   }
   /**
-  * Latest theoretical timeframe based on the last mutation in each feed.
-  * NOTE: This might never be reached if the mutation dependencies
+  * Called by AutomergeStorageAdapter after levelDB batch commit.
   */
-  // TODO(dmaretskyi): Rename `totalTimeframe`? or `lastTimeframe`.
-  get endTimeframe() {
-    return mapFeedIndexesToTimeframe(Array.from(this._feeds.values()).filter((feed) => feed.length > 0).map((feed) => ({
-      feedKey: feed.key,
-      index: feed.length - 1
-    })));
+  async _afterSave(path) {
+    this._indexMetadataStore.notifyMarkedDirty();
+    const documentId = path[0];
+    const document = this._repo.handles[documentId]?.docSync();
+    if (document) {
+      const heads = getHeads(document);
+      this._onHeadsChanged(documentId, heads);
+    }
   }
-  get startTimeframe() {
-    return this._startTimeframe;
+  _automergeDocs() {
+    return mapValues(this._repo.handles, (handle) => ({
+      state: handle.state,
+      hasDoc: !!handle.docSync(),
+      heads: handle.docSync() ? automerge.getHeads(handle.docSync()) : null,
+      data: handle.docSync() && 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}`;
+        }
+      })
+    }));
   }
-  get timeframe() {
-    return this._timeframeClock.timeframe;
+  _automergePeers() {
+    return this._repo.peers;
   }
-  get pendingTimeframe() {
-    return this._timeframeClock.pendingTimeframe;
+  async _getContainingSpaceForDocument(documentId) {
+    const doc = this._repo.handles[documentId]?.docSync();
+    if (!doc) {
+      return null;
+    }
+    const spaceKeyHex = getSpaceKeyFromDoc(doc);
+    if (!spaceKeyHex) {
+      return null;
+    }
+    return PublicKey2.from(spaceKeyHex);
   }
-  get targetTimeframe() {
-    return this._targetTimeframe ? this._targetTimeframe : new Timeframe2();
+  /**
+  * Flush documents to disk.
+  */
+  async flush({ documentIds } = {}) {
+    await this._repo.flush(documentIds);
   }
-  get reachedTarget() {
-    return this._reachedTarget;
+  async getHeads(documentIds) {
+    const result = [];
+    const storeRequestIds = [];
+    const storeResultIndices = [];
+    for (const documentId of documentIds) {
+      const doc = this._repo.handles[documentId]?.docSync();
+      if (doc) {
+        result.push(getHeads(doc));
+      } else {
+        storeRequestIds.push(documentId);
+        storeResultIndices.push(result.length);
+        result.push(void 0);
+      }
+    }
+    if (storeRequestIds.length > 0) {
+      const storedHeads = await this._headsStore.getHeads(storeRequestIds);
+      for (let i = 0; i < storedHeads.length; i++) {
+        result[storeResultIndices[i]] = storedHeads[i];
+      }
+    }
+    return result;
   }
-  get feeds() {
-    return Array.from(this._feeds.values());
+  //
+  // Collection sync.
+  //
+  getLocalCollectionState(collectionId) {
+    return this._collectionSynchronizer.getLocalCollectionState(collectionId);
   }
-  async waitUntilTimeframe(target) {
-    await this._timeframeClock.waitUntilReached(target);
+  getRemoteCollectionStates(collectionId) {
+    return this._collectionSynchronizer.getRemoteCollectionStates(collectionId);
   }
-  setTargetTimeframe(target) {
-    this._targetTimeframe = target;
+  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;
   }
   /**
-  * Wait until the pipeline processes all messages in the feed and reaches the target timeframe if that is set.
-  *
-  * This function will resolve immediately if the pipeline is stalled.
-  *
-  * @param timeout Timeout in milliseconds to specify the maximum wait time.
+  * Update the local collection state based on the locally stored document heads.
   */
-  async waitUntilReachedTargetTimeframe({ ctx = new Context2(void 0, {
-    F: __dxlog_file7,
-    L: 129
-  }), timeout, breakOnStall = true } = {}) {
-    log6("waitUntilReachedTargetTimeframe", {
-      timeout,
-      current: this.timeframe,
-      target: this.targetTimeframe
+  async updateLocalCollectionState(collectionId, documentIds) {
+    const heads = await this.getHeads(documentIds);
+    const documents = Object.fromEntries(heads.map((heads2, index) => [
+      documentIds[index],
+      heads2 ?? []
+    ]));
+    this._collectionSynchronizer.setLocalCollectionState(collectionId, {
+      documents
+    });
+  }
+  _onCollectionStateQueried(collectionId, peerId) {
+    this._collectionSynchronizer.onCollectionStateQueried(collectionId, peerId);
+  }
+  _onCollectionStateReceived(collectionId, peerId, state) {
+    this._collectionSynchronizer.onRemoteStateReceived(collectionId, peerId, decodeCollectionState(state));
+  }
+  _queryCollectionState(collectionId, peerId) {
+    this._echoNetworkAdapter.queryCollectionState(collectionId, peerId);
+  }
+  _sendCollectionState(collectionId, peerId, state) {
+    this._echoNetworkAdapter.sendCollectionState(collectionId, peerId, encodeCollectionState(state));
+  }
+  _onPeerConnected(peerId) {
+    this._collectionSynchronizer.onConnectionOpen(peerId);
+  }
+  _onPeerDisconnected(peerId) {
+    this._collectionSynchronizer.onConnectionClosed(peerId);
+  }
+  _onRemoteCollectionStateUpdated(collectionId, peerId) {
+    const localState = this._collectionSynchronizer.getLocalCollectionState(collectionId);
+    const remoteState = this._collectionSynchronizer.getRemoteCollectionStates(collectionId).get(peerId);
+    if (!localState || !remoteState) {
+      return;
+    }
+    const { different } = diffCollectionState(localState, remoteState);
+    if (different.length === 0) {
+      return;
+    }
+    log3.info("replication documents after collection sync", {
+      count: different.length
     }, {
-      F: __dxlog_file7,
-      L: 133,
+      F: __dxlog_file4,
+      L: 486,
       S: this,
       C: (f, a) => f(...a)
     });
-    this._reachedTargetPromise ??= Promise.race([
-      this._timeframeClock.update.waitForCondition(() => {
-        return Timeframe2.dependencies(this.targetTimeframe, this.timeframe).isEmpty();
-      }),
-      ...breakOnStall ? [
-        this.stalled.discardParameter().waitForCount(1)
-      ] : []
-    ]);
-    let done = false;
-    if (timeout) {
-      return Promise.race([
-        rejectOnDispose(ctx),
-        rejectOnDispose(this._ctx),
-        this._reachedTargetPromise.then(() => {
-          done = true;
-          this._reachedTarget = true;
-        }),
-        sleepWithContext(this._ctx, timeout).then(() => {
-          if (done) {
-            return;
-          }
-          log6.warn("waitUntilReachedTargetTimeframe timed out", {
-            timeout,
-            current: this.timeframe,
-            target: this.targetTimeframe,
-            dependencies: Timeframe2.dependencies(this.targetTimeframe, this.timeframe)
-          }, {
-            F: __dxlog_file7,
-            L: 161,
-            S: this,
-            C: (f, a) => f(...a)
+    for (const documentId of different) {
+      this._repo.find(documentId);
+    }
+  }
+  _onHeadsChanged(documentId, heads) {
+    for (const collectionId of this._collectionSynchronizer.getRegisteredCollectionIds()) {
+      const state = this._collectionSynchronizer.getLocalCollectionState(collectionId);
+      if (state?.documents[documentId]) {
+        const newState = structuredClone(state);
+        newState.documents[documentId] = heads;
+        this._collectionSynchronizer.setLocalCollectionState(collectionId, newState);
+      }
+    }
+  }
+};
+_ts_decorate2([
+  trace.info()
+], AutomergeHost.prototype, "_peerId", void 0);
+_ts_decorate2([
+  trace.info({
+    depth: null
+  })
+], AutomergeHost.prototype, "_automergeDocs", null);
+_ts_decorate2([
+  trace.info({
+    depth: null
+  })
+], AutomergeHost.prototype, "_automergePeers", null);
+_ts_decorate2([
+  trace.span({
+    showInBrowserTimeline: true
+  })
+], AutomergeHost.prototype, "flush", null);
+AutomergeHost = _ts_decorate2([
+  trace.resource()
+], AutomergeHost);
+var getSpaceKeyFromDoc = (doc) => {
+  const rawSpaceKey = doc.access?.spaceKey ?? doc.experimental_spaceKey;
+  if (rawSpaceKey == null) {
+    return null;
+  }
+  return String(rawSpaceKey);
+};
+var waitForHeads = async (handle, heads) => {
+  const unavailableHeads = new Set(heads);
+  await handle.whenReady();
+  await Event2.wrap(handle, "change").waitForCondition(() => {
+    for (const changeHash of unavailableHeads.values()) {
+      if (changeIsPresentInDoc(handle.docSync(), changeHash)) {
+        unavailableHeads.delete(changeHash);
+      }
+    }
+    return unavailableHeads.size === 0;
+  });
+};
+var changeIsPresentInDoc = (doc, changeHash) => {
+  return !!getBackend(doc).getChangeByHash(changeHash);
+};
+var decodeCollectionState = (state) => {
+  invariant4(typeof state === "object" && state !== null, "Invalid state", {
+    F: __dxlog_file4,
+    L: 539,
+    S: void 0,
+    A: [
+      "typeof state === 'object' && state !== null",
+      "'Invalid state'"
+    ]
+  });
+  return state;
+};
+var encodeCollectionState = (state) => {
+  return state;
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/space-collection.ts
+import { invariant as invariant5 } from "@dxos/invariant";
+import { SpaceId } from "@dxos/keys";
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/space-collection.ts";
+var deriveCollectionIdFromSpaceId = (spaceId) => `space:${spaceId}`;
+var getSpaceIdFromCollectionId = (collectionId) => {
+  const spaceId = collectionId.replace(/^space:/, "");
+  invariant5(SpaceId.isValid(spaceId), void 0, {
+    F: __dxlog_file5,
+    L: 12,
+    S: void 0,
+    A: [
+      "SpaceId.isValid(spaceId)",
+      ""
+    ]
+  });
+  return spaceId;
+};
+
+// packages/core/echo/echo-pipeline/src/space/auth.ts
+import { runInContext, scheduleTask as scheduleTask2 } from "@dxos/async";
+import { Context as Context2 } from "@dxos/context";
+import { randomBytes } from "@dxos/crypto";
+import { invariant as invariant6 } from "@dxos/invariant";
+import { log as log4 } from "@dxos/log";
+import { schema as schema4 } from "@dxos/protocols";
+import { RpcExtension } from "@dxos/teleport";
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/auth.ts";
+var AuthExtension = class extends RpcExtension {
+  constructor(_authParams) {
+    super({
+      requested: {
+        AuthService: schema4.getService("dxos.mesh.teleport.auth.AuthService")
+      },
+      exposed: {
+        AuthService: schema4.getService("dxos.mesh.teleport.auth.AuthService")
+      },
+      timeout: 60 * 1e3
+    });
+    this._authParams = _authParams;
+    this._ctx = new Context2({
+      onError: (err) => {
+        log4.catch(err, void 0, {
+          F: __dxlog_file6,
+          L: 28,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }, {
+      F: __dxlog_file6,
+      L: 26
+    });
+  }
+  async getHandlers() {
+    return {
+      AuthService: {
+        authenticate: async ({ challenge }) => {
+          try {
+            const credential = await this._authParams.provider(challenge);
+            if (!credential) {
+              throw new Error("auth rejected");
+            }
+            return {
+              credential
+            };
+          } catch (err) {
+            log4.error("failed to generate auth credentials", err, {
+              F: __dxlog_file6,
+              L: 55,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            throw new Error("auth rejected");
+          }
+        }
+      }
+    };
+  }
+  async onOpen(context) {
+    await super.onOpen(context);
+    scheduleTask2(this._ctx, async () => {
+      try {
+        const challenge = randomBytes(32);
+        const { credential } = await this.rpc.AuthService.authenticate({
+          challenge
+        });
+        invariant6(credential?.length > 0, "invalid credential", {
+          F: __dxlog_file6,
+          L: 69,
+          S: this,
+          A: [
+            "credential?.length > 0",
+            "'invalid credential'"
+          ]
+        });
+        const success = await this._authParams.verifier(challenge, credential);
+        invariant6(success, "credential not verified", {
+          F: __dxlog_file6,
+          L: 71,
+          S: this,
+          A: [
+            "success",
+            "'credential not verified'"
+          ]
+        });
+        runInContext(this._ctx, () => this._authParams.onAuthSuccess());
+      } catch (err) {
+        log4("auth failed", err, {
+          F: __dxlog_file6,
+          L: 74,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this.close();
+        this._authParams.onAuthFailure();
+      }
+    });
+  }
+  async onClose() {
+    await this._ctx.dispose();
+    await super.onClose();
+  }
+  async onAbort() {
+    await this._ctx.dispose();
+    await super.onAbort();
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/pipeline/timeframe-clock.ts
+import { Event as Event3 } from "@dxos/async";
+import { timed } from "@dxos/debug";
+import { log as log5 } from "@dxos/log";
+import { Timeframe } from "@dxos/timeframe";
+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 __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/pipeline/timeframe-clock.ts";
+var mapTimeframeToFeedIndexes = (timeframe) => timeframe.frames().map(([feedKey, index]) => ({
+  feedKey,
+  index
+}));
+var mapFeedIndexesToTimeframe = (indexes) => new Timeframe(indexes.map(({ feedKey, index }) => [
+  feedKey,
+  index
+]));
+var startAfter = (timeframe) => timeframe.frames().map(([feedKey, index]) => ({
+  feedKey,
+  index: index + 1
+}));
+var TimeframeClock = class {
+  constructor(_timeframe = new Timeframe()) {
+    this._timeframe = _timeframe;
+    this.update = new Event3();
+    this._pendingTimeframe = _timeframe;
+  }
+  /**
+  * Timeframe that was processed by ECHO.
+  */
+  get timeframe() {
+    return this._timeframe;
+  }
+  /**
+  * Timeframe that is currently being processed by ECHO.
+  * Will be equal to `timeframe` after the processing is complete.
+  */
+  get pendingTimeframe() {
+    return this._pendingTimeframe;
+  }
+  setTimeframe(timeframe) {
+    this._timeframe = timeframe;
+    this._pendingTimeframe = timeframe;
+    this.update.emit(this._timeframe);
+  }
+  updatePendingTimeframe(key, seq) {
+    this._pendingTimeframe = Timeframe.merge(this._pendingTimeframe, new Timeframe([
+      [
+        key,
+        seq
+      ]
+    ]));
+  }
+  updateTimeframe() {
+    this._timeframe = this._pendingTimeframe;
+    this.update.emit(this._timeframe);
+  }
+  hasGaps(timeframe) {
+    const gaps = Timeframe.dependencies(timeframe, this._timeframe);
+    return !gaps.isEmpty();
+  }
+  async waitUntilReached(target) {
+    log5("waitUntilReached", {
+      target,
+      current: this._timeframe
+    }, {
+      F: __dxlog_file7,
+      L: 70,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this.update.waitForCondition(() => {
+      log5("check if reached", {
+        target,
+        current: this._timeframe,
+        deps: Timeframe.dependencies(target, this._timeframe)
+      }, {
+        F: __dxlog_file7,
+        L: 72,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return Timeframe.dependencies(target, this._timeframe).isEmpty();
+    });
+  }
+};
+_ts_decorate3([
+  timed(5e3)
+], TimeframeClock.prototype, "waitUntilReached", null);
+
+// packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
+import { Event as Event4, sleepWithContext, synchronized as synchronized2, Trigger as Trigger2 } from "@dxos/async";
+import { Context as Context3, rejectOnDispose } from "@dxos/context";
+import { failUndefined } from "@dxos/debug";
+import { FeedSetIterator } from "@dxos/feed-store";
+import { invariant as invariant8 } from "@dxos/invariant";
+import { PublicKey as PublicKey3 } from "@dxos/keys";
+import { log as log7 } from "@dxos/log";
+import { Timeframe as Timeframe2 } from "@dxos/timeframe";
+import { ComplexMap } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/pipeline/message-selector.ts
+import { invariant as invariant7 } from "@dxos/invariant";
+import { log as log6 } from "@dxos/log";
+var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/pipeline/message-selector.ts";
+var createMessageSelector = (timeframeClock) => {
+  return (messages) => {
+    for (let i = 0; i < messages.length; i++) {
+      const { data: { timeframe } } = messages[i];
+      invariant7(timeframe, void 0, {
+        F: __dxlog_file8,
+        L: 25,
+        S: void 0,
+        A: [
+          "timeframe",
+          ""
+        ]
+      });
+      if (!timeframeClock.hasGaps(timeframe)) {
+        return i;
+      }
+    }
+    log6("Skipping...", void 0, {
+      F: __dxlog_file8,
+      L: 33,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file9 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts";
+var PipelineState = class {
+  constructor(_feeds, _timeframeClock) {
+    this._feeds = _feeds;
+    this._timeframeClock = _timeframeClock;
+    this._ctx = new Context3(void 0, {
+      F: __dxlog_file9,
+      L: 41
+    });
+    this.timeframeUpdate = this._timeframeClock.update;
+    this.stalled = new Event4();
+    this._startTimeframe = new Timeframe2();
+    this._reachedTarget = false;
+  }
+  /**
+  * Latest theoretical timeframe based on the last mutation in each feed.
+  * NOTE: This might never be reached if the mutation dependencies
+  */
+  // TODO(dmaretskyi): Rename `totalTimeframe`? or `lastTimeframe`.
+  get endTimeframe() {
+    return mapFeedIndexesToTimeframe(Array.from(this._feeds.values()).filter((feed) => feed.length > 0).map((feed) => ({
+      feedKey: feed.key,
+      index: feed.length - 1
+    })));
+  }
+  get startTimeframe() {
+    return this._startTimeframe;
+  }
+  get timeframe() {
+    return this._timeframeClock.timeframe;
+  }
+  get pendingTimeframe() {
+    return this._timeframeClock.pendingTimeframe;
+  }
+  get targetTimeframe() {
+    return this._targetTimeframe ? this._targetTimeframe : new Timeframe2();
+  }
+  get reachedTarget() {
+    return this._reachedTarget;
+  }
+  get feeds() {
+    return Array.from(this._feeds.values());
+  }
+  async waitUntilTimeframe(target) {
+    await this._timeframeClock.waitUntilReached(target);
+  }
+  setTargetTimeframe(target) {
+    this._targetTimeframe = target;
+  }
+  /**
+  * Wait until the pipeline processes all messages in the feed and reaches the target timeframe if that is set.
+  *
+  * This function will resolve immediately if the pipeline is stalled.
+  *
+  * @param timeout Timeout in milliseconds to specify the maximum wait time.
+  */
+  async waitUntilReachedTargetTimeframe({ ctx = new Context3(void 0, {
+    F: __dxlog_file9,
+    L: 129
+  }), timeout, breakOnStall = true } = {}) {
+    log7("waitUntilReachedTargetTimeframe", {
+      timeout,
+      current: this.timeframe,
+      target: this.targetTimeframe
+    }, {
+      F: __dxlog_file9,
+      L: 133,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._reachedTargetPromise ??= Promise.race([
+      this._timeframeClock.update.waitForCondition(() => {
+        return Timeframe2.dependencies(this.targetTimeframe, this.timeframe).isEmpty();
+      }),
+      ...breakOnStall ? [
+        this.stalled.discardParameter().waitForCount(1)
+      ] : []
+    ]);
+    let done = false;
+    if (timeout) {
+      return Promise.race([
+        rejectOnDispose(ctx),
+        rejectOnDispose(this._ctx),
+        this._reachedTargetPromise.then(() => {
+          done = true;
+          this._reachedTarget = true;
+        }),
+        sleepWithContext(this._ctx, timeout).then(() => {
+          if (done) {
+            return;
+          }
+          log7.warn("waitUntilReachedTargetTimeframe timed out", {
+            timeout,
+            current: this.timeframe,
+            target: this.targetTimeframe,
+            dependencies: Timeframe2.dependencies(this.targetTimeframe, this.timeframe)
+          }, {
+            F: __dxlog_file9,
+            L: 161,
+            S: this,
+            C: (f, a) => f(...a)
           });
         })
       ]);
@@ -961,14 +1747,14 @@ var PipelineState = class {
 var Pipeline = class {
   constructor() {
     this._timeframeClock = new TimeframeClock(new Timeframe2());
-    this._feeds = new ComplexMap2(PublicKey3.hash);
+    this._feeds = new ComplexMap(PublicKey3.hash);
     // External state accessor.
     this._state = new PipelineState(this._feeds, this._timeframeClock);
     // Waits for the message consumer to process the message and yield control back to the pipeline.
-    this._processingTrigger = new Trigger().wake();
-    this._pauseTrigger = new Trigger().wake();
+    this._processingTrigger = new Trigger2().wake();
+    this._pauseTrigger = new Trigger2().wake();
     // Pending downloads.
-    this._downloads = new ComplexMap2((value) => PublicKey3.hash(value.key));
+    this._downloads = new ComplexMap((value) => PublicKey3.hash(value.key));
     this._isStopping = false;
     this._isStarted = false;
     this._isBeingConsumed = false;
@@ -978,8 +1764,8 @@ var Pipeline = class {
     return this._state;
   }
   get writer() {
-    invariant6(this._writer, "Writer not set.", {
-      F: __dxlog_file7,
+    invariant8(this._writer, "Writer not set.", {
+      F: __dxlog_file9,
       L: 243,
       S: this,
       A: [
@@ -1007,8 +1793,8 @@ var Pipeline = class {
     }
   }
   setWriteFeed(feed) {
-    invariant6(!this._writer, "Writer already set.", {
-      F: __dxlog_file7,
+    invariant8(!this._writer, "Writer already set.", {
+      F: __dxlog_file9,
       L: 270,
       S: this,
       A: [
@@ -1016,8 +1802,8 @@ var Pipeline = class {
         "'Writer already set.'"
       ]
     });
-    invariant6(feed.properties.writable, "Feed must be writable.", {
-      F: __dxlog_file7,
+    invariant8(feed.properties.writable, "Feed must be writable.", {
+      F: __dxlog_file9,
       L: 271,
       S: this,
       A: [
@@ -1031,8 +1817,8 @@ var Pipeline = class {
     }), feed.createFeedWriter());
   }
   async start() {
-    invariant6(!this._isStarted, "Pipeline is already started.", {
-      F: __dxlog_file7,
+    invariant8(!this._isStarted, "Pipeline is already started.", {
+      F: __dxlog_file9,
       L: 284,
       S: this,
       A: [
@@ -1040,8 +1826,8 @@ var Pipeline = class {
         "'Pipeline is already started.'"
       ]
     });
-    log6("starting...", void 0, {
-      F: __dxlog_file7,
+    log7("starting...", void 0, {
+      F: __dxlog_file9,
       L: 285,
       S: this,
       C: (f, a) => f(...a)
@@ -1049,8 +1835,8 @@ var Pipeline = class {
     await this._initIterator();
     await this._feedSetIterator.open();
     this._isStarted = true;
-    log6("started", void 0, {
-      F: __dxlog_file7,
+    log7("started", void 0, {
+      F: __dxlog_file9,
       L: 289,
       S: this,
       C: (f, a) => f(...a)
@@ -1062,8 +1848,8 @@ var Pipeline = class {
     }
   }
   async stop() {
-    log6("stopping...", void 0, {
-      F: __dxlog_file7,
+    log7("stopping...", void 0, {
+      F: __dxlog_file9,
       L: 300,
       S: this,
       C: (f, a) => f(...a)
@@ -1076,15 +1862,15 @@ var Pipeline = class {
     await this._feedSetIterator?.close();
     await this._processingTrigger.wait();
     await this._state._ctx.dispose();
-    this._state._ctx = new Context2(void 0, {
-      F: __dxlog_file7,
+    this._state._ctx = new Context3(void 0, {
+      F: __dxlog_file9,
       L: 309
     });
     this._state._reachedTargetPromise = void 0;
     this._state._reachedTarget = false;
     this._isStarted = false;
-    log6("stopped", void 0, {
-      F: __dxlog_file7,
+    log7("stopped", void 0, {
+      F: __dxlog_file9,
       L: 313,
       S: this,
       C: (f, a) => f(...a)
@@ -1095,8 +1881,8 @@ var Pipeline = class {
   *  The pipeline will start processing messages AFTER this timeframe.
   */
   async setCursor(timeframe) {
-    invariant6(!this._isStarted || this._isPaused, "Invalid state.", {
-      F: __dxlog_file7,
+    invariant8(!this._isStarted || this._isPaused, "Invalid state.", {
+      F: __dxlog_file9,
       L: 322,
       S: this,
       A: [
@@ -1124,8 +1910,8 @@ var Pipeline = class {
     this._isPaused = true;
   }
   async unpause() {
-    invariant6(this._isPaused, "Pipeline is not paused.", {
-      F: __dxlog_file7,
+    invariant8(this._isPaused, "Pipeline is not paused.", {
+      F: __dxlog_file9,
       L: 351,
       S: this,
       A: [
@@ -1144,8 +1930,8 @@ var Pipeline = class {
   * Updates the timeframe clock after the message has bee processed.
   */
   async *consume() {
-    invariant6(!this._isBeingConsumed, "Pipeline is already being consumed.", {
-      F: __dxlog_file7,
+    invariant8(!this._isBeingConsumed, "Pipeline is already being consumed.", {
+      F: __dxlog_file9,
       L: 366,
       S: this,
       A: [
@@ -1154,8 +1940,8 @@ var Pipeline = class {
       ]
     });
     this._isBeingConsumed = true;
-    invariant6(this._feedSetIterator, "Iterator not initialized.", {
-      F: __dxlog_file7,
+    invariant8(this._feedSetIterator, "Iterator not initialized.", {
+      F: __dxlog_file9,
       L: 369,
       S: this,
       A: [
@@ -1168,8 +1954,8 @@ var Pipeline = class {
     while (!this._isStopping) {
       await this._pauseTrigger.wait();
       if (lastFeedSetIterator !== this._feedSetIterator) {
-        invariant6(this._feedSetIterator, "Iterator not initialized.", {
-          F: __dxlog_file7,
+        invariant8(this._feedSetIterator, "Iterator not initialized.", {
+          F: __dxlog_file9,
           L: 378,
           S: this,
           A: [
@@ -1199,12 +1985,12 @@ var Pipeline = class {
     }
     const timeframe = this._state._startTimeframe;
     const seq = timeframe.get(feed.key) ?? -1;
-    log6("download", {
+    log7("download", {
       feed: feed.key.truncate(),
       seq,
       length: feed.length
     }, {
-      F: __dxlog_file7,
+      F: __dxlog_file9,
       L: 407,
       S: this,
       C: (f, a) => f(...a)
@@ -1215,10 +2001,10 @@ var Pipeline = class {
     }, (err, data) => {
       if (err) {
       } else {
-        log6.info("downloaded", {
+        log7.info("downloaded", {
           data
         }, {
-          F: __dxlog_file7,
+          F: __dxlog_file9,
           L: 412,
           S: this,
           C: (f, a) => f(...a)
@@ -1233,8 +2019,8 @@ var Pipeline = class {
       stallTimeout: 1e3
     });
     this._feedSetIterator.stalled.on((iterator) => {
-      log6.warn(`Stalled after ${iterator.options.stallTimeout}ms with ${iterator.size} feeds.`, void 0, {
-        F: __dxlog_file7,
+      log7.warn(`Stalled after ${iterator.options.stallTimeout}ms with ${iterator.size} feeds.`, void 0, {
+        F: __dxlog_file9,
         L: 426,
         S: this,
         C: (f, a) => f(...a)
@@ -1246,142 +2032,32 @@ var Pipeline = class {
     }
   }
 };
-_ts_decorate3([
+_ts_decorate4([
   synchronized2
 ], Pipeline.prototype, "start", null);
-_ts_decorate3([
+_ts_decorate4([
   synchronized2
 ], Pipeline.prototype, "stop", null);
-_ts_decorate3([
+_ts_decorate4([
   synchronized2
 ], Pipeline.prototype, "setCursor", null);
-_ts_decorate3([
+_ts_decorate4([
   synchronized2
 ], Pipeline.prototype, "pause", null);
-_ts_decorate3([
+_ts_decorate4([
   synchronized2
 ], Pipeline.prototype, "unpause", null);
 
-// packages/core/echo/echo-pipeline/src/space/auth.ts
-import { runInContext, scheduleTask } from "@dxos/async";
-import { Context as Context3 } from "@dxos/context";
-import { randomBytes } from "@dxos/crypto";
-import { invariant as invariant7 } from "@dxos/invariant";
-import { log as log7 } from "@dxos/log";
-import { schema as schema5 } from "@dxos/protocols";
-import { RpcExtension } from "@dxos/teleport";
-var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/auth.ts";
-var AuthExtension = class extends RpcExtension {
-  constructor(_authParams) {
-    super({
-      requested: {
-        AuthService: schema5.getService("dxos.mesh.teleport.auth.AuthService")
-      },
-      exposed: {
-        AuthService: schema5.getService("dxos.mesh.teleport.auth.AuthService")
-      },
-      timeout: 60 * 1e3
-    });
-    this._authParams = _authParams;
-    this._ctx = new Context3({
-      onError: (err) => {
-        log7.catch(err, void 0, {
-          F: __dxlog_file8,
-          L: 28,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    }, {
-      F: __dxlog_file8,
-      L: 26
-    });
-  }
-  async getHandlers() {
-    return {
-      AuthService: {
-        authenticate: async ({ challenge }) => {
-          try {
-            const credential = await this._authParams.provider(challenge);
-            if (!credential) {
-              throw new Error("auth rejected");
-            }
-            return {
-              credential
-            };
-          } catch (err) {
-            log7.error("failed to generate auth credentials", err, {
-              F: __dxlog_file8,
-              L: 55,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            throw new Error("auth rejected");
-          }
-        }
-      }
-    };
-  }
-  async onOpen(context) {
-    await super.onOpen(context);
-    scheduleTask(this._ctx, async () => {
-      try {
-        const challenge = randomBytes(32);
-        const { credential } = await this.rpc.AuthService.authenticate({
-          challenge
-        });
-        invariant7(credential?.length > 0, "invalid credential", {
-          F: __dxlog_file8,
-          L: 69,
-          S: this,
-          A: [
-            "credential?.length > 0",
-            "'invalid credential'"
-          ]
-        });
-        const success = await this._authParams.verifier(challenge, credential);
-        invariant7(success, "credential not verified", {
-          F: __dxlog_file8,
-          L: 71,
-          S: this,
-          A: [
-            "success",
-            "'credential not verified'"
-          ]
-        });
-        runInContext(this._ctx, () => this._authParams.onAuthSuccess());
-      } catch (err) {
-        log7("auth failed", err, {
-          F: __dxlog_file8,
-          L: 74,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this.close();
-        this._authParams.onAuthFailure();
-      }
-    });
-  }
-  async onClose() {
-    await this._ctx.dispose();
-    await super.onClose();
-  }
-  async onAbort() {
-    await this._ctx.dispose();
-    await super.onAbort();
-  }
-};
-
 // packages/core/echo/echo-pipeline/src/space/space.ts
-import { Event as Event4, Mutex, synchronized as synchronized3, trackLeaks as trackLeaks2 } from "@dxos/async";
-import { LifecycleState, Resource as Resource2 } from "@dxos/context";
+import { Event as Event5, Mutex, synchronized as synchronized3, trackLeaks as trackLeaks2 } from "@dxos/async";
+import { LifecycleState as LifecycleState3, Resource as Resource5 } from "@dxos/context";
 import { subtleCrypto as subtleCrypto2 } from "@dxos/crypto";
-import { invariant as invariant8 } from "@dxos/invariant";
-import { PublicKey as PublicKey5, SpaceId } from "@dxos/keys";
+import { invariant as invariant9 } from "@dxos/invariant";
+import { PublicKey as PublicKey5, SpaceId as SpaceId2 } from "@dxos/keys";
 import { log as log9, logInfo } from "@dxos/log";
 import { AdmittedFeed as AdmittedFeed2 } from "@dxos/protocols/proto/dxos/halo/credentials";
-import { trace as trace2 } from "@dxos/tracing";
-import { Callback as Callback2, ComplexMap as ComplexMap3 } from "@dxos/util";
+import { trace as trace3 } from "@dxos/tracing";
+import { Callback as Callback2, ComplexMap as ComplexMap2 } from "@dxos/util";
 
 // packages/core/echo/echo-pipeline/src/space/control-pipeline.ts
 import { DeferredTask, sleepWithContext as sleepWithContext2, trackLeaks } from "@dxos/async";
@@ -1391,9 +2067,9 @@ import { PublicKey as PublicKey4 } from "@dxos/keys";
 import { log as log8 } from "@dxos/log";
 import { AdmittedFeed } from "@dxos/protocols/proto/dxos/halo/credentials";
 import { Timeframe as Timeframe3 } from "@dxos/timeframe";
-import { TimeSeriesCounter, TimeUsageCounter, trace } from "@dxos/tracing";
+import { TimeSeriesCounter, TimeUsageCounter, trace as trace2 } from "@dxos/tracing";
 import { Callback, tracer } from "@dxos/util";
-function _ts_decorate4(decorators, target, key, desc) {
+function _ts_decorate5(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);
@@ -1403,14 +2079,14 @@ function _ts_decorate4(decorators, target, key, desc) {
         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_file9 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/control-pipeline.ts";
+var __dxlog_file10 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/control-pipeline.ts";
 var TIMEFRAME_SAVE_DEBOUNCE_INTERVAL = 500;
 var CONTROL_PIPELINE_SNAPSHOT_DELAY = 1e4;
 var USE_SNAPSHOTS = true;
 var ControlPipeline = class {
   constructor({ spaceKey, genesisFeed, feedProvider, metadataStore }) {
     this._ctx = new Context4(void 0, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 47
     });
     this._lastTimeframeSaveTime = Date.now();
@@ -1430,7 +2106,7 @@ var ControlPipeline = class {
       log8("feed admitted", {
         key: info.key
       }, {
-        F: __dxlog_file9,
+        F: __dxlog_file10,
         L: 82,
         S: this,
         C: (f, a) => f(...a)
@@ -1444,7 +2120,7 @@ var ControlPipeline = class {
             }
           } catch (err) {
             log8.catch(err, void 0, {
-              F: __dxlog_file9,
+              F: __dxlog_file10,
               L: 93,
               S: this,
               C: (f, a) => f(...a)
@@ -1476,7 +2152,7 @@ var ControlPipeline = class {
       present: !!snapshot,
       tf: snapshot?.timeframe
     }, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 123,
       S: this,
       C: (f, a) => f(...a)
@@ -1485,20 +2161,20 @@ var ControlPipeline = class {
       await this._processSnapshot(snapshot);
     }
     log8("starting...", void 0, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 128,
       S: this,
       C: (f, a) => f(...a)
     });
     setTimeout(async () => {
       void this._consumePipeline(new Context4(void 0, {
-        F: __dxlog_file9,
+        F: __dxlog_file10,
         L: 130
       }));
     });
     await this._pipeline.start();
     log8("started", void 0, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 134,
       S: this,
       C: (f, a) => f(...a)
@@ -1515,7 +2191,7 @@ var ControlPipeline = class {
         log8.warn("credential processing failed from snapshot", {
           message
         }, {
-          F: __dxlog_file9,
+          F: __dxlog_file10,
           L: 147,
           S: this,
           C: (f, a) => f(...a)
@@ -1537,7 +2213,7 @@ var ControlPipeline = class {
       key: this._spaceKey,
       snapshot
     }, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 163,
       S: this,
       C: (f, a) => f(...a)
@@ -1552,7 +2228,7 @@ var ControlPipeline = class {
         await this._processMessage(ctx, msg);
       } catch (err) {
         log8.catch(err, void 0, {
-          F: __dxlog_file9,
+          F: __dxlog_file10,
           L: 176,
           S: this,
           C: (f, a) => f(...a)
@@ -1566,7 +2242,7 @@ var ControlPipeline = class {
       key: msg.feedKey,
       seq: msg.seq
     }, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 186,
       S: this,
       C: (f, a) => f(...a)
@@ -1581,7 +2257,7 @@ var ControlPipeline = class {
         log8.warn("processing failed", {
           msg
         }, {
-          F: __dxlog_file9,
+          F: __dxlog_file10,
           L: 195,
           S: this,
           C: (f, a) => f(...a)
@@ -1600,7 +2276,7 @@ var ControlPipeline = class {
   }
   async stop() {
     log8("stopping...", void 0, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 215,
       S: this,
       C: (f, a) => f(...a)
@@ -1609,7 +2285,7 @@ var ControlPipeline = class {
     await this._pipeline.stop();
     await this._saveTargetTimeframe(this._pipeline.state.timeframe);
     log8("stopped", void 0, {
-      F: __dxlog_file9,
+      F: __dxlog_file10,
       L: 219,
       S: this,
       C: (f, a) => f(...a)
@@ -1622,7 +2298,7 @@ var ControlPipeline = class {
       this._targetTimeframe = newTimeframe;
     } catch (err) {
       log8(err, void 0, {
-        F: __dxlog_file9,
+        F: __dxlog_file10,
         L: 228,
         S: this,
         C: (f, a) => f(...a)
@@ -1630,30 +2306,30 @@ var ControlPipeline = class {
     }
   }
 };
-_ts_decorate4([
-  trace.metricsCounter()
+_ts_decorate5([
+  trace2.metricsCounter()
 ], ControlPipeline.prototype, "_usage", void 0);
-_ts_decorate4([
-  trace.metricsCounter()
+_ts_decorate5([
+  trace2.metricsCounter()
 ], ControlPipeline.prototype, "_mutations", void 0);
-_ts_decorate4([
-  trace.span({
+_ts_decorate5([
+  trace2.span({
     showInBrowserTimeline: true
   })
 ], ControlPipeline.prototype, "start", null);
-_ts_decorate4([
-  trace.span()
+_ts_decorate5([
+  trace2.span()
 ], ControlPipeline.prototype, "_consumePipeline", null);
-_ts_decorate4([
-  trace.span()
+_ts_decorate5([
+  trace2.span()
 ], ControlPipeline.prototype, "_processMessage", null);
-ControlPipeline = _ts_decorate4([
-  trace.resource(),
+ControlPipeline = _ts_decorate5([
+  trace2.resource(),
   trackLeaks("start", "stop")
 ], ControlPipeline);
 
 // packages/core/echo/echo-pipeline/src/space/space.ts
-function _ts_decorate5(decorators, target, key, desc) {
+function _ts_decorate6(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);
@@ -1663,15 +2339,15 @@ function _ts_decorate5(decorators, target, key, desc) {
         r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-var __dxlog_file10 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/space.ts";
-var Space = class extends Resource2 {
+var __dxlog_file11 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/space.ts";
+var Space = class extends Resource5 {
   constructor(params) {
     super();
     this._addFeedMutex = new Mutex();
     this.onCredentialProcessed = new Callback2();
-    this.stateUpdate = new Event4();
-    invariant8(params.spaceKey && params.feedProvider, void 0, {
-      F: __dxlog_file10,
+    this.stateUpdate = new Event5();
+    invariant9(params.spaceKey && params.feedProvider, void 0, {
+      F: __dxlog_file11,
       L: 78,
       S: this,
       A: [
@@ -1705,7 +2381,7 @@ var Space = class extends Resource2 {
       log9("onCredentialProcessed", {
         credential
       }, {
-        F: __dxlog_file10,
+        F: __dxlog_file11,
         L: 106,
         S: this,
         C: (f, a) => f(...a)
@@ -1716,7 +2392,7 @@ var Space = class extends Resource2 {
       log9("onDelegatedInvitation", {
         invitation
       }, {
-        F: __dxlog_file10,
+        F: __dxlog_file11,
         L: 110,
         S: this,
         C: (f, a) => f(...a)
@@ -1727,7 +2403,7 @@ var Space = class extends Resource2 {
       log9("onDelegatedInvitationRemoved", {
         invitation
       }, {
-        F: __dxlog_file10,
+        F: __dxlog_file11,
         L: 114,
         S: this,
         C: (f, a) => f(...a)
@@ -1741,7 +2417,7 @@ var Space = class extends Resource2 {
           m.role
         ])
       }), {
-        F: __dxlog_file10,
+        F: __dxlog_file11,
         L: 118,
         S: this,
         C: (f, a) => f(...a)
@@ -1758,7 +2434,7 @@ var Space = class extends Resource2 {
     return this._key;
   }
   get isOpen() {
-    return this._lifecycleState === LifecycleState.OPEN;
+    return this._lifecycleState === LifecycleState3.OPEN;
   }
   get genesisFeedKey() {
     return this._genesisFeedKey;
@@ -1782,8 +2458,8 @@ var Space = class extends Resource2 {
     return this._snapshotManager;
   }
   async setControlFeed(feed) {
-    invariant8(!this._controlFeed, "Control feed already set.", {
-      F: __dxlog_file10,
+    invariant9(!this._controlFeed, "Control feed already set.", {
+      F: __dxlog_file11,
       L: 171,
       S: this,
       A: [
@@ -1796,8 +2472,8 @@ var Space = class extends Resource2 {
     return this;
   }
   async setDataFeed(feed) {
-    invariant8(!this._dataFeed, "Data feed already set.", {
-      F: __dxlog_file10,
+    invariant9(!this._dataFeed, "Data feed already set.", {
+      F: __dxlog_file11,
       L: 178,
       S: this,
       A: [
@@ -1816,7 +2492,7 @@ var Space = class extends Resource2 {
   }
   async _open(ctx) {
     log9("opening...", void 0, {
-      F: __dxlog_file10,
+      F: __dxlog_file11,
       L: 192,
       S: this,
       C: (f, a) => f(...a)
@@ -1824,7 +2500,7 @@ var Space = class extends Resource2 {
     await this._controlPipeline.start();
     await this.protocol.start();
     log9("opened", void 0, {
-      F: __dxlog_file10,
+      F: __dxlog_file11,
       L: 198,
       S: this,
       C: (f, a) => f(...a)
@@ -1834,7 +2510,7 @@ var Space = class extends Resource2 {
     log9("closing...", {
       key: this._key
     }, {
-      F: __dxlog_file10,
+      F: __dxlog_file11,
       L: 203,
       S: this,
       C: (f, a) => f(...a)
@@ -1842,67 +2518,67 @@ var Space = class extends Resource2 {
     await this.protocol.stop();
     await this._controlPipeline.stop();
     log9("closed", void 0, {
-      F: __dxlog_file10,
+      F: __dxlog_file11,
       L: 209,
       S: this,
       C: (f, a) => f(...a)
     });
   }
 };
-_ts_decorate5([
-  trace2.info()
+_ts_decorate6([
+  trace3.info()
 ], Space.prototype, "protocol", void 0);
-_ts_decorate5([
-  trace2.info()
+_ts_decorate6([
+  trace3.info()
 ], Space.prototype, "_controlPipeline", void 0);
-_ts_decorate5([
+_ts_decorate6([
   logInfo,
-  trace2.info()
+  trace3.info()
 ], Space.prototype, "id", null);
-_ts_decorate5([
+_ts_decorate6([
   logInfo,
-  trace2.info()
+  trace3.info()
 ], Space.prototype, "key", null);
-_ts_decorate5([
-  trace2.span()
+_ts_decorate6([
+  trace3.span()
 ], Space.prototype, "_open", null);
-_ts_decorate5([
+_ts_decorate6([
   synchronized3
 ], Space.prototype, "_close", null);
-Space = _ts_decorate5([
+Space = _ts_decorate6([
   trackLeaks2("open", "close"),
-  trace2.resource()
+  trace3.resource()
 ], Space);
-var SPACE_IDS_CACHE = new ComplexMap3(PublicKey5.hash);
+var SPACE_IDS_CACHE = new ComplexMap2(PublicKey5.hash);
 var createIdFromSpaceKey = async (spaceKey) => {
   const cachedValue = SPACE_IDS_CACHE.get(spaceKey);
   if (cachedValue !== void 0) {
     return cachedValue;
   }
   const digest = await subtleCrypto2.digest("SHA-256", spaceKey.asUint8Array());
-  const bytes = new Uint8Array(digest).slice(0, SpaceId.byteLength);
-  const spaceId = SpaceId.encode(bytes);
+  const bytes = new Uint8Array(digest).slice(0, SpaceId2.byteLength);
+  const spaceId = SpaceId2.encode(bytes);
   SPACE_IDS_CACHE.set(spaceKey, spaceId);
   return spaceId;
 };
 
 // packages/core/echo/echo-pipeline/src/space/admission-discovery-extension.ts
-import { scheduleTask as scheduleTask2 } from "@dxos/async";
+import { scheduleTask as scheduleTask3 } from "@dxos/async";
 import { Context as Context5 } from "@dxos/context";
-import { ProtocolError, schema as schema6 } from "@dxos/protocols";
+import { ProtocolError, schema as schema5 } from "@dxos/protocols";
 import { RpcExtension as RpcExtension2 } from "@dxos/teleport";
-var __dxlog_file11 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/admission-discovery-extension.ts";
+var __dxlog_file12 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/admission-discovery-extension.ts";
 var CredentialRetrieverExtension = class extends RpcExtension2 {
   constructor(_request, _onResult) {
     super({
       requested: {
-        AdmissionDiscoveryService: schema6.getService("dxos.mesh.teleport.AdmissionDiscoveryService")
+        AdmissionDiscoveryService: schema5.getService("dxos.mesh.teleport.AdmissionDiscoveryService")
       }
     });
     this._request = _request;
     this._onResult = _onResult;
     this._ctx = new Context5(void 0, {
-      F: __dxlog_file11,
+      F: __dxlog_file12,
       L: 25
     });
   }
@@ -1911,7 +2587,7 @@ var CredentialRetrieverExtension = class extends RpcExtension2 {
   }
   async onOpen(context) {
     await super.onOpen(context);
-    scheduleTask2(this._ctx, async () => {
+    scheduleTask3(this._ctx, async () => {
       try {
         const result = await this.rpc.AdmissionDiscoveryService.getAdmissionCredential(this._request);
         this._onResult.wake(result.admissionCredential);
@@ -1919,267 +2595,719 @@ var CredentialRetrieverExtension = class extends RpcExtension2 {
         context.close(err);
       }
     });
-  }
-  async onClose() {
-    await this._ctx.dispose();
-  }
-  async onAbort() {
-    await this._ctx.dispose();
-  }
-};
-var CredentialServerExtension = class extends RpcExtension2 {
-  constructor(_space) {
-    super({
-      exposed: {
-        AdmissionDiscoveryService: schema6.getService("dxos.mesh.teleport.AdmissionDiscoveryService")
+  }
+  async onClose() {
+    await this._ctx.dispose();
+  }
+  async onAbort() {
+    await this._ctx.dispose();
+  }
+};
+var CredentialServerExtension = class extends RpcExtension2 {
+  constructor(_space) {
+    super({
+      exposed: {
+        AdmissionDiscoveryService: schema5.getService("dxos.mesh.teleport.AdmissionDiscoveryService")
+      }
+    });
+    this._space = _space;
+  }
+  async getHandlers() {
+    return {
+      AdmissionDiscoveryService: {
+        getAdmissionCredential: async (request) => {
+          const memberInfo = this._space.spaceState.members.get(request.memberKey);
+          if (!memberInfo?.credential) {
+            throw new ProtocolError("Space member not found.", request);
+          }
+          return {
+            admissionCredential: memberInfo.credential
+          };
+        }
+      }
+    };
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/space/space-protocol.ts
+import { discoveryKey, subtleCrypto as subtleCrypto3 } from "@dxos/crypto";
+import { PublicKey as PublicKey6 } from "@dxos/keys";
+import { log as log10, logInfo as logInfo2 } from "@dxos/log";
+import { MMSTTopology } from "@dxos/network-manager";
+import { Teleport } from "@dxos/teleport";
+import { BlobSync } from "@dxos/teleport-extension-object-sync";
+import { ReplicatorExtension } from "@dxos/teleport-extension-replicator";
+import { trace as trace4 } from "@dxos/tracing";
+import { ComplexMap as ComplexMap3 } from "@dxos/util";
+function _ts_decorate7(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_file13 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/space-protocol.ts";
+var MOCK_AUTH_PROVIDER = async (nonce) => Buffer.from("mock");
+var MOCK_AUTH_VERIFIER = async (nonce, credential) => true;
+var SpaceProtocol = class {
+  constructor({ topic, swarmIdentity, networkManager, onSessionAuth, onAuthFailure, blobStore }) {
+    this._feeds = /* @__PURE__ */ new Set();
+    this._sessions = new ComplexMap3(PublicKey6.hash);
+    // TODO(burdon): Move to config (with sensible defaults).
+    this._topology = new MMSTTopology({
+      originateConnections: 4,
+      maxPeers: 10,
+      sampleSize: 20
+    });
+    this._spaceKey = topic;
+    this._networkManager = networkManager;
+    this._swarmIdentity = swarmIdentity;
+    this._onSessionAuth = onSessionAuth;
+    this._onAuthFailure = onAuthFailure;
+    this.blobSync = new BlobSync({
+      blobStore
+    });
+    this._topic = subtleCrypto3.digest("SHA-256", topic.asBuffer()).then(discoveryKey).then(PublicKey6.from);
+  }
+  get sessions() {
+    return this._sessions;
+  }
+  get feeds() {
+    return this._feeds;
+  }
+  get _ownPeerKey() {
+    return this._swarmIdentity.peerKey;
+  }
+  // TODO(burdon): Create abstraction for Space (e.g., add keys and have provider).
+  addFeed(feed) {
+    log10("addFeed", {
+      key: feed.key
+    }, {
+      F: __dxlog_file13,
+      L: 109,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._feeds.add(feed);
+    for (const session of this._sessions.values()) {
+      session.replicator.addFeed(feed);
+    }
+  }
+  // TODO(burdon): Rename open? Common open/close interfaces for all services?
+  async start() {
+    if (this._connection) {
+      return;
+    }
+    const credentials = await this._swarmIdentity.credentialProvider(Buffer.from(""));
+    await this.blobSync.open();
+    log10("starting...", void 0, {
+      F: __dxlog_file13,
+      L: 128,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const topic = await this._topic;
+    this._connection = await this._networkManager.joinSwarm({
+      protocolProvider: this._createProtocolProvider(credentials),
+      peerId: this._swarmIdentity.peerKey,
+      topic,
+      topology: this._topology,
+      label: `swarm ${topic.truncate()} for space ${this._spaceKey.truncate()}`
+    });
+    log10("started", void 0, {
+      F: __dxlog_file13,
+      L: 138,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  updateTopology() {
+    this._topology.forceUpdate();
+  }
+  async stop() {
+    await this.blobSync.close();
+    if (this._connection) {
+      log10("stopping...", void 0, {
+        F: __dxlog_file13,
+        L: 149,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      await this._connection.close();
+      log10("stopped", void 0, {
+        F: __dxlog_file13,
+        L: 151,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
+  _createProtocolProvider(credentials) {
+    return (wireParams) => {
+      const session = new SpaceProtocolSession({
+        wireParams,
+        swarmIdentity: this._swarmIdentity,
+        onSessionAuth: this._onSessionAuth,
+        onAuthFailure: this._onAuthFailure,
+        blobSync: this.blobSync
+      });
+      this._sessions.set(wireParams.remotePeerId, session);
+      for (const feed of this._feeds) {
+        session.replicator.addFeed(feed);
+      }
+      return session;
+    };
+  }
+};
+_ts_decorate7([
+  logInfo2,
+  trace4.info()
+], SpaceProtocol.prototype, "_topic", void 0);
+_ts_decorate7([
+  trace4.info()
+], SpaceProtocol.prototype, "_spaceKey", void 0);
+_ts_decorate7([
+  logInfo2
+], SpaceProtocol.prototype, "_ownPeerKey", null);
+SpaceProtocol = _ts_decorate7([
+  trace4.resource()
+], SpaceProtocol);
+var AuthStatus;
+(function(AuthStatus2) {
+  AuthStatus2["INITIAL"] = "INITIAL";
+  AuthStatus2["SUCCESS"] = "SUCCESS";
+  AuthStatus2["FAILURE"] = "FAILURE";
+})(AuthStatus || (AuthStatus = {}));
+var SpaceProtocolSession = class {
+  // TODO(dmaretskyi): Allow to pass in extra extensions.
+  constructor({ wireParams, swarmIdentity, onSessionAuth, onAuthFailure, blobSync }) {
+    // TODO(dmaretskyi): Start with upload=false when switching it on the fly works.
+    this.replicator = new ReplicatorExtension().setOptions({
+      upload: true
+    });
+    this._authStatus = "INITIAL";
+    this._wireParams = wireParams;
+    this._swarmIdentity = swarmIdentity;
+    this._onSessionAuth = onSessionAuth;
+    this._onAuthFailure = onAuthFailure;
+    this._blobSync = blobSync;
+    this._teleport = new Teleport(wireParams);
+  }
+  get authStatus() {
+    return this._authStatus;
+  }
+  get stats() {
+    return this._teleport.stats;
+  }
+  get stream() {
+    return this._teleport.stream;
+  }
+  async open(sessionId) {
+    await this._teleport.open(sessionId);
+    this._teleport.addExtension("dxos.mesh.teleport.auth", new AuthExtension({
+      provider: this._swarmIdentity.credentialProvider,
+      verifier: this._swarmIdentity.credentialAuthenticator,
+      onAuthSuccess: () => {
+        log10("Peer authenticated", void 0, {
+          F: __dxlog_file13,
+          L: 248,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._authStatus = "SUCCESS";
+        this._onSessionAuth?.(this._teleport);
+      },
+      onAuthFailure: () => {
+        this._authStatus = "FAILURE";
+        this._onAuthFailure?.(this._teleport);
+      }
+    }));
+    this._teleport.addExtension("dxos.mesh.teleport.replicator", this.replicator);
+    this._teleport.addExtension("dxos.mesh.teleport.blobsync", this._blobSync.createExtension());
+  }
+  async close() {
+    log10("close", void 0, {
+      F: __dxlog_file13,
+      L: 264,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._teleport.close();
+  }
+  async abort() {
+    await this._teleport.abort();
+  }
+};
+_ts_decorate7([
+  logInfo2
+], SpaceProtocolSession.prototype, "_wireParams", void 0);
+_ts_decorate7([
+  logInfo2
+], SpaceProtocolSession.prototype, "authStatus", null);
+
+// packages/core/echo/echo-pipeline/src/space/space-manager.ts
+import { synchronized as synchronized4, trackLeaks as trackLeaks3, Trigger as Trigger3 } from "@dxos/async";
+import { failUndefined as failUndefined2 } from "@dxos/debug";
+import { PublicKey as PublicKey8 } from "@dxos/keys";
+import { log as log14 } from "@dxos/log";
+import { trace as trace5 } from "@dxos/protocols";
+import { ComplexMap as ComplexMap4 } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/db-host/data-service.ts
+import { Stream } from "@dxos/codec-protobuf";
+import { invariant as invariant12 } from "@dxos/invariant";
+import { SpaceId as SpaceId3 } from "@dxos/keys";
+import { log as log13 } from "@dxos/log";
+
+// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts
+import { invariant as invariant11 } from "@dxos/invariant";
+import { PublicKey as PublicKey7 } from "@dxos/keys";
+import { log as log12 } from "@dxos/log";
+import { ComplexSet, defaultMap as defaultMap2 } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator-connection.ts
+import { cbor } from "@dxos/automerge/automerge-repo";
+import { Resource as Resource6 } from "@dxos/context";
+import { invariant as invariant10 } from "@dxos/invariant";
+import { log as log11 } from "@dxos/log";
+import { AutomergeReplicator } from "@dxos/teleport-extension-automerge-replicator";
+var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator-connection.ts";
+var DEFAULT_FACTORY = (params) => new AutomergeReplicator(...params);
+var MeshReplicatorConnection = class extends Resource6 {
+  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) => {
+        invariant10(this._isEnabled, "Writing to a disabled connection", {
+          F: __dxlog_file14,
+          L: 48,
+          S: this,
+          A: [
+            "this._isEnabled",
+            "'Writing to a disabled connection'"
+          ]
+        });
+        try {
+          await this.replicatorExtension.sendSyncMessage({
+            payload: cbor.encode(message)
+          });
+        } catch (err) {
+          controller.error(err);
+          this._disconnectIfEnabled();
+        }
       }
     });
-    this._space = _space;
-  }
-  async getHandlers() {
-    return {
-      AdmissionDiscoveryService: {
-        getAdmissionCredential: async (request) => {
-          const memberInfo = this._space.spaceState.members.get(request.memberKey);
-          if (!memberInfo?.credential) {
-            throw new ProtocolError("Space member not found.", request);
+    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;
+          log11("onStartReplication", {
+            id: info.id,
+            thisPeerId: this.peerId,
+            remotePeerId: remotePeerId.toHex()
+          }, {
+            F: __dxlog_file14,
+            L: 82,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._params.onRemoteConnected();
+        },
+        onSyncMessage: async ({ payload }) => {
+          if (!this._isEnabled) {
+            return;
           }
-          return {
-            admissionCredential: memberInfo.credential
-          };
+          const message = cbor.decode(payload);
+          readableStreamController.enqueue(message);
+        },
+        onClose: async () => {
+          this._disconnectIfEnabled();
         }
       }
-    };
+    ]);
   }
-};
-
-// packages/core/echo/echo-pipeline/src/space/space-protocol.ts
-import { discoveryKey, subtleCrypto as subtleCrypto3 } from "@dxos/crypto";
-import { PublicKey as PublicKey6 } from "@dxos/keys";
-import { log as log10, logInfo as logInfo2 } from "@dxos/log";
-import { MMSTTopology } from "@dxos/network-manager";
-import { Teleport } from "@dxos/teleport";
-import { BlobSync } from "@dxos/teleport-extension-object-sync";
-import { ReplicatorExtension } from "@dxos/teleport-extension-replicator";
-import { trace as trace3 } from "@dxos/tracing";
-import { ComplexMap as ComplexMap4 } from "@dxos/util";
-function _ts_decorate6(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_file12 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/space-protocol.ts";
-var MOCK_AUTH_PROVIDER = async (nonce) => Buffer.from("mock");
-var MOCK_AUTH_VERIFIER = async (nonce, credential) => true;
-var SpaceProtocol = class {
-  constructor({ topic, swarmIdentity, networkManager, onSessionAuth, onAuthFailure, blobStore }) {
-    this._feeds = /* @__PURE__ */ new Set();
-    this._sessions = new ComplexMap4(PublicKey6.hash);
-    // TODO(burdon): Move to config (with sensible defaults).
-    this._topology = new MMSTTopology({
-      originateConnections: 4,
-      maxPeers: 10,
-      sampleSize: 20
-    });
-    this._spaceKey = topic;
-    this._networkManager = networkManager;
-    this._swarmIdentity = swarmIdentity;
-    this._onSessionAuth = onSessionAuth;
-    this._onAuthFailure = onAuthFailure;
-    this.blobSync = new BlobSync({
-      blobStore
-    });
-    this._topic = subtleCrypto3.digest("SHA-256", topic.asBuffer()).then(discoveryKey).then(PublicKey6.from);
+  _disconnectIfEnabled() {
+    if (this._isEnabled) {
+      this._params.onRemoteDisconnected();
+    }
   }
-  get sessions() {
-    return this._sessions;
+  get peerId() {
+    invariant10(this._remotePeerId != null, "Remote peer has not connected yet.", {
+      F: __dxlog_file14,
+      L: 108,
+      S: this,
+      A: [
+        "this._remotePeerId != null",
+        "'Remote peer has not connected yet.'"
+      ]
+    });
+    return this._remotePeerId;
   }
-  get feeds() {
-    return this._feeds;
+  async shouldAdvertise(params) {
+    return this._params.shouldAdvertise(params);
   }
-  get _ownPeerKey() {
-    return this._swarmIdentity.peerKey;
+  shouldSyncCollection(params) {
+    return this._params.shouldSyncCollection(params);
   }
-  // TODO(burdon): Create abstraction for Space (e.g., add keys and have provider).
-  addFeed(feed) {
-    log10("addFeed", {
-      key: feed.key
-    }, {
-      F: __dxlog_file12,
-      L: 109,
+  /**
+  * Start exchanging messages with the remote peer.
+  * Call after the remote peer has connected.
+  */
+  enable() {
+    invariant10(this._remotePeerId != null, "Remote peer has not connected yet.", {
+      F: __dxlog_file14,
+      L: 125,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "this._remotePeerId != null",
+        "'Remote peer has not connected yet.'"
+      ]
     });
-    this._feeds.add(feed);
-    for (const session of this._sessions.values()) {
-      session.replicator.addFeed(feed);
-    }
+    this._isEnabled = true;
   }
-  // TODO(burdon): Rename open? Common open/close interfaces for all services?
-  async start() {
-    if (this._connection) {
-      return;
+  /**
+  * Stop exchanging messages with the remote peer.
+  */
+  disable() {
+    this._isEnabled = false;
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts
+var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts";
+var MeshEchoReplicator = class {
+  constructor() {
+    this._connections = /* @__PURE__ */ new Set();
+    /**
+    * Using automerge peerId as a key.
+    */
+    this._connectionsPerPeer = /* @__PURE__ */ new Map();
+    /**
+    * spaceId -> deviceKey[]
+    */
+    this._authorizedDevices = /* @__PURE__ */ new Map();
+    this._context = null;
+  }
+  async connect(context) {
+    this._context = context;
+  }
+  async disconnect() {
+    for (const connection of this._connectionsPerPeer.values()) {
+      this._context?.onConnectionClosed(connection);
     }
-    const credentials = await this._swarmIdentity.credentialProvider(Buffer.from(""));
-    await this.blobSync.open();
-    log10("starting...", void 0, {
-      F: __dxlog_file12,
-      L: 128,
+    for (const connection of this._connections) {
+      await connection.close();
+    }
+    this._connections.clear();
+    this._connectionsPerPeer.clear();
+    this._context = null;
+  }
+  createExtension(extensionFactory) {
+    invariant11(this._context, void 0, {
+      F: __dxlog_file15,
+      L: 56,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "this._context",
+        ""
+      ]
     });
-    const topic = await this._topic;
-    this._connection = await this._networkManager.joinSwarm({
-      protocolProvider: this._createProtocolProvider(credentials),
-      peerId: this._swarmIdentity.peerKey,
-      topic,
-      topology: this._topology,
-      label: `swarm ${topic.truncate()} for space ${this._spaceKey.truncate()}`
+    const connection = new MeshReplicatorConnection({
+      ownPeerId: this._context.peerId,
+      replicatorFactory: extensionFactory,
+      onRemoteConnected: async () => {
+        log12("onRemoteConnected", {
+          peerId: connection.peerId
+        }, {
+          F: __dxlog_file15,
+          L: 62,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        invariant11(this._context, void 0, {
+          F: __dxlog_file15,
+          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 () => {
+        log12("onRemoteDisconnected", {
+          peerId: connection.peerId
+        }, {
+          F: __dxlog_file15,
+          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) => {
+        log12("shouldAdvertise", {
+          peerId: connection.peerId,
+          documentId: params.documentId
+        }, {
+          F: __dxlog_file15,
+          L: 81,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        invariant11(this._context, void 0, {
+          F: __dxlog_file15,
+          L: 82,
+          S: this,
+          A: [
+            "this._context",
+            ""
+          ]
+        });
+        try {
+          const spaceKey = await this._context.getContainingSpaceForDocument(params.documentId);
+          if (!spaceKey) {
+            log12("space key not found for share policy check", {
+              peerId: connection.peerId,
+              documentId: params.documentId
+            }, {
+              F: __dxlog_file15,
+              L: 86,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return false;
+          }
+          const spaceId = await createIdFromSpaceKey(spaceKey);
+          const authorizedDevices = this._authorizedDevices.get(spaceId);
+          if (!connection.remoteDeviceKey) {
+            log12("device key not found for share policy check", {
+              peerId: connection.peerId,
+              documentId: params.documentId
+            }, {
+              F: __dxlog_file15,
+              L: 98,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return false;
+          }
+          const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
+          log12("share policy check", {
+            localPeer: this._context.peerId,
+            remotePeer: connection.peerId,
+            documentId: params.documentId,
+            deviceKey: connection.remoteDeviceKey,
+            spaceKey,
+            isAuthorized
+          }, {
+            F: __dxlog_file15,
+            L: 106,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return isAuthorized;
+        } catch (err) {
+          log12.catch(err, void 0, {
+            F: __dxlog_file15,
+            L: 116,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return false;
+        }
+      },
+      shouldSyncCollection: ({ collectionId }) => {
+        const spaceId = getSpaceIdFromCollectionId(collectionId);
+        const authorizedDevices = this._authorizedDevices.get(spaceId);
+        if (!connection.remoteDeviceKey) {
+          log12("device key not found for collection sync check", {
+            peerId: connection.peerId,
+            collectionId
+          }, {
+            F: __dxlog_file15,
+            L: 126,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return false;
+        }
+        const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
+        return isAuthorized;
+      }
     });
-    log10("started", void 0, {
-      F: __dxlog_file12,
-      L: 138,
+    this._connections.add(connection);
+    return connection.replicatorExtension;
+  }
+  async authorizeDevice(spaceKey, deviceKey) {
+    log12("authorizeDevice", {
+      spaceKey,
+      deviceKey
+    }, {
+      F: __dxlog_file15,
+      L: 143,
       S: this,
       C: (f, a) => f(...a)
     });
+    const spaceId = await createIdFromSpaceKey(spaceKey);
+    defaultMap2(this._authorizedDevices, spaceId, () => new ComplexSet(PublicKey7.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);
+        }
+      }
+    }
   }
-  updateTopology() {
-    this._topology.forceUpdate();
+};
+
+// packages/core/echo/echo-pipeline/src/db-host/data-service.ts
+var __dxlog_file16 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/data-service.ts";
+var DataServiceImpl = class {
+  constructor(params) {
+    /**
+    * Map of subscriptions.
+    * subscriptionId -> DocumentsSynchronizer
+    */
+    this._subscriptions = /* @__PURE__ */ new Map();
+    this._automergeHost = params.automergeHost;
+    this._updateIndexes = params.updateIndexes;
   }
-  async stop() {
-    await this.blobSync.close();
-    if (this._connection) {
-      log10("stopping...", void 0, {
-        F: __dxlog_file12,
-        L: 149,
-        S: this,
-        C: (f, a) => f(...a)
+  subscribe(request) {
+    return new Stream(({ next, ready }) => {
+      const synchronizer = new DocumentsSynchronizer({
+        repo: this._automergeHost.repo,
+        sendUpdates: (updates) => next(updates)
       });
-      await this._connection.close();
-      log10("stopped", void 0, {
-        F: __dxlog_file12,
-        L: 151,
+      synchronizer.open().then(() => {
+        this._subscriptions.set(request.subscriptionId, synchronizer);
+        ready();
+      }).catch((err) => log13.catch(err, void 0, {
+        F: __dxlog_file16,
+        L: 64,
         S: this,
         C: (f, a) => f(...a)
-      });
+      }));
+      return () => synchronizer.close();
+    });
+  }
+  async updateSubscription(request) {
+    const synchronizer = this._subscriptions.get(request.subscriptionId);
+    invariant12(synchronizer, "Subscription not found", {
+      F: __dxlog_file16,
+      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);
+    invariant12(synchronizer, "Subscription not found", {
+      F: __dxlog_file16,
+      L: 86,
+      S: this,
+      A: [
+        "synchronizer",
+        "'Subscription not found'"
+      ]
+    });
+    synchronizer.update(request.updates);
   }
-  _createProtocolProvider(credentials) {
-    return (wireParams) => {
-      const session = new SpaceProtocolSession({
-        wireParams,
-        swarmIdentity: this._swarmIdentity,
-        onSessionAuth: this._onSessionAuth,
-        onAuthFailure: this._onAuthFailure,
-        blobSync: this.blobSync
-      });
-      this._sessions.set(wireParams.remotePeerId, session);
-      for (const feed of this._feeds) {
-        session.replicator.addFeed(feed);
+  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
+        }))
       }
-      return session;
     };
   }
-};
-_ts_decorate6([
-  logInfo2,
-  trace3.info()
-], SpaceProtocol.prototype, "_topic", void 0);
-_ts_decorate6([
-  trace3.info()
-], SpaceProtocol.prototype, "_spaceKey", void 0);
-_ts_decorate6([
-  logInfo2
-], SpaceProtocol.prototype, "_ownPeerKey", null);
-SpaceProtocol = _ts_decorate6([
-  trace3.resource()
-], SpaceProtocol);
-var AuthStatus;
-(function(AuthStatus2) {
-  AuthStatus2["INITIAL"] = "INITIAL";
-  AuthStatus2["SUCCESS"] = "SUCCESS";
-  AuthStatus2["FAILURE"] = "FAILURE";
-})(AuthStatus || (AuthStatus = {}));
-var SpaceProtocolSession = class {
-  // TODO(dmaretskyi): Allow to pass in extra extensions.
-  constructor({ wireParams, swarmIdentity, onSessionAuth, onAuthFailure, blobSync }) {
-    // TODO(dmaretskyi): Start with upload=false when switching it on the fly works.
-    this.replicator = new ReplicatorExtension().setOptions({
-      upload: true
-    });
-    this._authStatus = "INITIAL";
-    this._wireParams = wireParams;
-    this._swarmIdentity = swarmIdentity;
-    this._onSessionAuth = onSessionAuth;
-    this._onAuthFailure = onAuthFailure;
-    this._blobSync = blobSync;
-    this._teleport = new Teleport(wireParams);
-  }
-  get authStatus() {
-    return this._authStatus;
-  }
-  get stats() {
-    return this._teleport.stats;
+  async waitUntilHeadsReplicated(request, options) {
+    await this._automergeHost.waitUntilHeadsReplicated(request.heads);
   }
-  get stream() {
-    return this._teleport.stream;
+  async reIndexHeads(request, options) {
+    await this._automergeHost.reIndexHeads(request.documentIds ?? []);
   }
-  async open(sessionId) {
-    await this._teleport.open(sessionId);
-    this._teleport.addExtension("dxos.mesh.teleport.auth", new AuthExtension({
-      provider: this._swarmIdentity.credentialProvider,
-      verifier: this._swarmIdentity.credentialAuthenticator,
-      onAuthSuccess: () => {
-        log10("Peer authenticated", void 0, {
-          F: __dxlog_file12,
-          L: 248,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._authStatus = "SUCCESS";
-        this._onSessionAuth?.(this._teleport);
-      },
-      onAuthFailure: () => {
-        this._authStatus = "FAILURE";
-        this._onAuthFailure?.(this._teleport);
-      }
-    }));
-    this._teleport.addExtension("dxos.mesh.teleport.replicator", this.replicator);
-    this._teleport.addExtension("dxos.mesh.teleport.blobsync", this._blobSync.createExtension());
+  async updateIndexes() {
+    await this._updateIndexes();
   }
-  async close() {
-    log10("close", void 0, {
-      F: __dxlog_file12,
-      L: 264,
+  async getSpaceSyncState(request, options) {
+    invariant12(SpaceId3.isValid(request.spaceId), void 0, {
+      F: __dxlog_file16,
+      L: 127,
       S: this,
-      C: (f, a) => f(...a)
+      A: [
+        "SpaceId.isValid(request.spaceId)",
+        ""
+      ]
     });
-    await this._teleport.close();
-  }
-  async abort() {
-    await this._teleport.abort();
+    const collectionId = deriveCollectionIdFromSpaceId(request.spaceId);
+    const state = await this._automergeHost.getCollectionSyncState(collectionId);
+    return {
+      peers: state.peers.map((peer) => ({
+        peerId: peer.peerId,
+        documentsToReconcile: peer.differentDocuments
+      }))
+    };
   }
 };
-_ts_decorate6([
-  logInfo2
-], SpaceProtocolSession.prototype, "_wireParams", void 0);
-_ts_decorate6([
-  logInfo2
-], SpaceProtocolSession.prototype, "authStatus", null);
 
 // packages/core/echo/echo-pipeline/src/space/space-manager.ts
-import { synchronized as synchronized4, trackLeaks as trackLeaks3, Trigger as Trigger2 } from "@dxos/async";
-import { failUndefined as failUndefined2 } from "@dxos/debug";
-import { PublicKey as PublicKey7 } from "@dxos/keys";
-import { log as log11 } from "@dxos/log";
-import { trace as trace4 } from "@dxos/protocols";
-import { ComplexMap as ComplexMap5 } from "@dxos/util";
-function _ts_decorate7(decorators, target, key, desc) {
+function _ts_decorate8(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);
@@ -2189,11 +3317,11 @@ function _ts_decorate7(decorators, target, key, desc) {
         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_file13 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/space-manager.ts";
+var __dxlog_file17 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/space/space-manager.ts";
 var SpaceManager = class {
   constructor({ feedStore, networkManager, metadataStore, snapshotStore, blobStore }) {
-    this._spaces = new ComplexMap5(PublicKey7.hash);
-    this._instanceId = PublicKey7.random().toHex();
+    this._spaces = new ComplexMap4(PublicKey8.hash);
+    this._instanceId = PublicKey8.random().toHex();
     this._feedStore = feedStore;
     this._networkManager = networkManager;
     this._metadataStore = metadataStore;
@@ -2212,18 +3340,18 @@ var SpaceManager = class {
     ].map((space) => space.close()));
   }
   async constructSpace({ metadata, swarmIdentity, onAuthorizedConnection, onAuthFailure, onDelegatedInvitationStatusChange, onMemberRolesChanged, memberKey }) {
-    log11.trace("dxos.echo.space-manager.construct-space", trace4.begin({
+    log14.trace("dxos.echo.space-manager.construct-space", trace5.begin({
       id: this._instanceId
     }), {
-      F: __dxlog_file13,
+      F: __dxlog_file17,
       L: 103,
       S: this,
       C: (f, a) => f(...a)
     });
-    log11("constructing space...", {
+    log14("constructing space...", {
       spaceKey: metadata.genesisFeedKey
     }, {
-      F: __dxlog_file13,
+      F: __dxlog_file17,
       L: 104,
       S: this,
       C: (f, a) => f(...a)
@@ -2253,10 +3381,10 @@ var SpaceManager = class {
       onMemberRolesChanged
     });
     this._spaces.set(space.key, space);
-    log11.trace("dxos.echo.space-manager.construct-space", trace4.end({
+    log14.trace("dxos.echo.space-manager.construct-space", trace5.end({
       id: this._instanceId
     }), {
-      F: __dxlog_file13,
+      F: __dxlog_file17,
       L: 135,
       S: this,
       C: (f, a) => f(...a)
@@ -2265,93 +3393,439 @@ var SpaceManager = class {
   }
   async requestSpaceAdmissionCredential(params) {
     const traceKey = "dxos.echo.space-manager.request-space-admission";
-    log11.trace(traceKey, trace4.begin({
+    log14.trace(traceKey, trace5.begin({
       id: this._instanceId
     }), {
-      F: __dxlog_file13,
+      F: __dxlog_file17,
       L: 141,
       S: this,
       C: (f, a) => f(...a)
     });
-    log11("requesting space admission credential...", {
+    log14("requesting space admission credential...", {
       spaceKey: params.spaceKey
     }, {
-      F: __dxlog_file13,
-      L: 142,
+      F: __dxlog_file17,
+      L: 142,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const onCredentialResolved = new Trigger3();
+    const protocol = new SpaceProtocol({
+      topic: params.spaceKey,
+      swarmIdentity: params.swarmIdentity,
+      networkManager: this._networkManager,
+      onSessionAuth: (session) => {
+        session.addExtension("dxos.mesh.teleport.admission-discovery", new CredentialRetrieverExtension({
+          spaceKey: params.spaceKey,
+          memberKey: params.identityKey
+        }, onCredentialResolved));
+      },
+      onAuthFailure: (session) => session.close(),
+      blobStore: this._blobStore
+    });
+    try {
+      await protocol.start();
+      const credential = await onCredentialResolved.wait({
+        timeout: params.timeout
+      });
+      log14.trace(traceKey, trace5.end({
+        id: this._instanceId
+      }), {
+        F: __dxlog_file17,
+        L: 165,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return credential;
+    } catch (err) {
+      log14.trace(traceKey, trace5.error({
+        id: this._instanceId,
+        error: err
+      }), {
+        F: __dxlog_file17,
+        L: 168,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      throw err;
+    } finally {
+      await protocol.stop();
+    }
+  }
+};
+_ts_decorate8([
+  synchronized4
+], SpaceManager.prototype, "open", null);
+_ts_decorate8([
+  synchronized4
+], SpaceManager.prototype, "close", null);
+SpaceManager = _ts_decorate8([
+  trackLeaks3("open", "close")
+], SpaceManager);
+
+// packages/core/echo/echo-pipeline/src/metadata/metadata-store.ts
+import CRC32 from "crc-32";
+import { Event as Event6, scheduleTaskInterval as scheduleTaskInterval2, synchronized as synchronized5 } from "@dxos/async";
+import { Context as Context6 } from "@dxos/context";
+import { invariant as invariant13 } from "@dxos/invariant";
+import { PublicKey as PublicKey9 } from "@dxos/keys";
+import { log as log15 } from "@dxos/log";
+import { DataCorruptionError, STORAGE_VERSION, schema as schema6 } from "@dxos/protocols";
+import { Invitation, SpaceState } from "@dxos/protocols/proto/dxos/client/services";
+import { ComplexMap as ComplexMap5, arrayToBuffer, forEachAsync, isNotNullOrUndefined } from "@dxos/util";
+function _ts_decorate9(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_file18 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/metadata/metadata-store.ts";
+var EXPIRED_INVITATION_CLEANUP_INTERVAL = 60 * 60 * 1e3;
+var emptyEchoMetadata = () => ({
+  version: STORAGE_VERSION,
+  spaces: [],
+  created: /* @__PURE__ */ new Date(),
+  updated: /* @__PURE__ */ new Date()
+});
+var emptyLargeSpaceMetadata = () => ({});
+var EchoMetadata = schema6.getCodecForType("dxos.echo.metadata.EchoMetadata");
+var LargeSpaceMetadata = schema6.getCodecForType("dxos.echo.metadata.LargeSpaceMetadata");
+var MetadataStore = class {
+  constructor(directory) {
+    this._metadata = emptyEchoMetadata();
+    this._spaceLargeMetadata = new ComplexMap5(PublicKey9.hash);
+    this._metadataFile = void 0;
+    this.update = new Event6();
+    this._invitationCleanupCtx = new Context6(void 0, {
+      F: __dxlog_file18,
+      L: 53
+    });
+    this._directory = directory;
+  }
+  get metadata() {
+    return this._metadata;
+  }
+  get version() {
+    return this._metadata.version ?? 0;
+  }
+  /**
+  * Returns a list of currently saved spaces. The list and objects in it can be modified addSpace and
+  * addSpaceFeed functions.
+  */
+  get spaces() {
+    return this._metadata.spaces ?? [];
+  }
+  async _readFile(file, codec2) {
+    try {
+      const { size: fileLength } = await file.stat();
+      if (fileLength < 8) {
+        return;
+      }
+      const dataSize = fromBytesInt32(await file.read(0, 4));
+      const checksum = fromBytesInt32(await file.read(4, 4));
+      log15("loaded", {
+        size: dataSize,
+        checksum,
+        name: file.filename
+      }, {
+        F: __dxlog_file18,
+        L: 89,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (fileLength < dataSize + 8) {
+        throw new DataCorruptionError("Metadata size is smaller than expected.", {
+          fileLength,
+          dataSize
+        });
+      }
+      const data = await file.read(8, dataSize);
+      const calculatedChecksum = CRC32.buf(data);
+      if (calculatedChecksum !== checksum) {
+        throw new DataCorruptionError("Metadata checksum is invalid.");
+      }
+      return codec2.decode(data);
+    } finally {
+      await file.close();
+    }
+  }
+  /**
+  * @internal
+  */
+  async _writeFile(file, codec2, data) {
+    const encoded = arrayToBuffer(codec2.encode(data));
+    const checksum = CRC32.buf(encoded);
+    const result = Buffer.alloc(8 + encoded.length);
+    result.writeInt32LE(encoded.length, 0);
+    result.writeInt32LE(checksum, 4);
+    encoded.copy(result, 8);
+    await file.write(0, result);
+    log15("saved", {
+      size: encoded.length,
+      checksum
+    }, {
+      F: __dxlog_file18,
+      L: 124,
       S: this,
       C: (f, a) => f(...a)
     });
-    const onCredentialResolved = new Trigger2();
-    const protocol = new SpaceProtocol({
-      topic: params.spaceKey,
-      swarmIdentity: params.swarmIdentity,
-      networkManager: this._networkManager,
-      onSessionAuth: (session) => {
-        session.addExtension("dxos.mesh.teleport.admission-discovery", new CredentialRetrieverExtension({
-          spaceKey: params.spaceKey,
-          memberKey: params.identityKey
-        }, onCredentialResolved));
-      },
-      onAuthFailure: (session) => session.close(),
-      blobStore: this._blobStore
-    });
+  }
+  async close() {
+    await this._invitationCleanupCtx.dispose();
+    await this.flush();
+    await this._metadataFile?.close();
+    this._metadataFile = void 0;
+    this._metadata = emptyEchoMetadata();
+    this._spaceLargeMetadata.clear();
+  }
+  /**
+  * Loads metadata from persistent storage.
+  */
+  async load() {
+    if (!this._metadataFile || this._metadataFile.closed) {
+      this._metadataFile = this._directory.getOrCreateFile("EchoMetadata");
+    }
     try {
-      await protocol.start();
-      const credential = await onCredentialResolved.wait({
-        timeout: params.timeout
+      const metadata = await this._readFile(this._metadataFile, EchoMetadata);
+      if (metadata) {
+        this._metadata = metadata;
+      }
+      this._metadata.spaces?.forEach((space) => {
+        space.state ??= SpaceState.ACTIVE;
       });
-      log11.trace(traceKey, trace4.end({
-        id: this._instanceId
-      }), {
-        F: __dxlog_file13,
-        L: 165,
+    } catch (err) {
+      log15.error("failed to load metadata", {
+        err
+      }, {
+        F: __dxlog_file18,
+        L: 156,
         S: this,
         C: (f, a) => f(...a)
       });
-      return credential;
+      this._metadata = emptyEchoMetadata();
+    }
+    await forEachAsync([
+      this._metadata.identity?.haloSpace.key,
+      ...this._metadata.spaces?.map((space) => space.key) ?? []
+    ].filter(isNotNullOrUndefined), async (key) => {
+      try {
+        await this._loadSpaceLargeMetadata(key);
+      } catch (err) {
+        log15.error("failed to load space large metadata", {
+          err
+        }, {
+          F: __dxlog_file18,
+          L: 168,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    });
+    scheduleTaskInterval2(this._invitationCleanupCtx, async () => {
+      for (const invitation of this._metadata.invitations ?? []) {
+        if (hasInvitationExpired(invitation) || isLegacyInvitationFormat(invitation)) {
+          await this.removeInvitation(invitation.invitationId);
+        }
+      }
+    }, EXPIRED_INVITATION_CLEANUP_INTERVAL);
+  }
+  async _save() {
+    const data = {
+      ...this._metadata,
+      version: STORAGE_VERSION,
+      created: this._metadata.created ?? /* @__PURE__ */ new Date(),
+      updated: /* @__PURE__ */ new Date()
+    };
+    this.update.emit(data);
+    const file = this._directory.getOrCreateFile("EchoMetadata");
+    await this._writeFile(file, EchoMetadata, data);
+  }
+  async _loadSpaceLargeMetadata(key) {
+    const file = this._directory.getOrCreateFile(`space_${key.toHex()}_large`);
+    try {
+      const metadata = await this._readFile(file, LargeSpaceMetadata);
+      if (metadata) {
+        this._spaceLargeMetadata.set(key, metadata);
+      }
     } catch (err) {
-      log11.trace(traceKey, trace4.error({
-        id: this._instanceId,
-        error: err
-      }), {
-        F: __dxlog_file13,
-        L: 168,
+      log15.error("failed to load space large metadata", {
+        err
+      }, {
+        F: __dxlog_file18,
+        L: 210,
         S: this,
         C: (f, a) => f(...a)
       });
-      throw err;
-    } finally {
-      await protocol.stop();
     }
   }
+  async _saveSpaceLargeMetadata(key) {
+    const data = this._getLargeSpaceMetadata(key);
+    const file = this._directory.getOrCreateFile(`space_${key.toHex()}_large`);
+    await this._writeFile(file, LargeSpaceMetadata, data);
+  }
+  async flush() {
+    await this._directory.flush();
+  }
+  _getSpace(spaceKey) {
+    if (this._metadata.identity?.haloSpace.key.equals(spaceKey)) {
+      return this._metadata.identity.haloSpace;
+    }
+    const space = this.spaces.find((space2) => space2.key === spaceKey);
+    invariant13(space, "Space not found", {
+      F: __dxlog_file18,
+      L: 232,
+      S: this,
+      A: [
+        "space",
+        "'Space not found'"
+      ]
+    });
+    return space;
+  }
+  _getLargeSpaceMetadata(key) {
+    let entry = this._spaceLargeMetadata.get(key);
+    if (entry) {
+      return entry;
+    }
+    entry = emptyLargeSpaceMetadata();
+    this._spaceLargeMetadata.set(key, entry);
+    return entry;
+  }
+  /**
+  * Clears storage - doesn't work for now.
+  */
+  async clear() {
+    log15("clearing all metadata", void 0, {
+      F: __dxlog_file18,
+      L: 251,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._directory.delete();
+    this._metadata = emptyEchoMetadata();
+  }
+  getIdentityRecord() {
+    return this._metadata.identity;
+  }
+  async setIdentityRecord(record) {
+    invariant13(!this._metadata.identity, "Cannot overwrite existing identity in metadata", {
+      F: __dxlog_file18,
+      L: 261,
+      S: this,
+      A: [
+        "!this._metadata.identity",
+        "'Cannot overwrite existing identity in metadata'"
+      ]
+    });
+    this._metadata.identity = record;
+    await this._save();
+    await this.flush();
+  }
+  getInvitations() {
+    return this._metadata.invitations ?? [];
+  }
+  async addInvitation(invitation) {
+    if (this._metadata.invitations?.find((i) => i.invitationId === invitation.invitationId)) {
+      return;
+    }
+    (this._metadata.invitations ??= []).push(invitation);
+    await this._save();
+    await this.flush();
+  }
+  async removeInvitation(invitationId) {
+    this._metadata.invitations = (this._metadata.invitations ?? []).filter((i) => i.invitationId !== invitationId);
+    await this._save();
+    await this.flush();
+  }
+  async addSpace(record) {
+    invariant13(!(this._metadata.spaces ?? []).find((space) => space.key === record.key), "Cannot overwrite existing space in metadata", {
+      F: __dxlog_file18,
+      L: 289,
+      S: this,
+      A: [
+        "!(this._metadata.spaces ?? []).find((space) => space.key === record.key)",
+        "'Cannot overwrite existing space in metadata'"
+      ]
+    });
+    (this._metadata.spaces ??= []).push(record);
+    await this._save();
+    await this.flush();
+  }
+  async setSpaceDataLatestTimeframe(spaceKey, timeframe) {
+    this._getSpace(spaceKey).dataTimeframe = timeframe;
+    await this._save();
+  }
+  async setSpaceControlLatestTimeframe(spaceKey, timeframe) {
+    this._getSpace(spaceKey).controlTimeframe = timeframe;
+    await this._save();
+    await this.flush();
+  }
+  async setCache(spaceKey, cache) {
+    this._getSpace(spaceKey).cache = cache;
+    await this._save();
+  }
+  async setWritableFeedKeys(spaceKey, controlFeedKey, dataFeedKey) {
+    const space = this._getSpace(spaceKey);
+    space.controlFeedKey = controlFeedKey;
+    space.dataFeedKey = dataFeedKey;
+    await this._save();
+    await this.flush();
+  }
+  async setSpaceState(spaceKey, state) {
+    this._getSpace(spaceKey).state = state;
+    await this._save();
+    await this.flush();
+  }
+  getSpaceControlPipelineSnapshot(spaceKey) {
+    return this._getLargeSpaceMetadata(spaceKey).controlPipelineSnapshot;
+  }
+  async setSpaceControlPipelineSnapshot(spaceKey, snapshot) {
+    this._getLargeSpaceMetadata(spaceKey).controlPipelineSnapshot = snapshot;
+    await this._saveSpaceLargeMetadata(spaceKey);
+    await this.flush();
+  }
+};
+_ts_decorate9([
+  synchronized5
+], MetadataStore.prototype, "load", null);
+_ts_decorate9([
+  synchronized5
+], MetadataStore.prototype, "_save", null);
+_ts_decorate9([
+  synchronized5
+], MetadataStore.prototype, "_saveSpaceLargeMetadata", null);
+var fromBytesInt32 = (buf) => buf.readInt32LE(0);
+var hasInvitationExpired = (invitation) => {
+  return Boolean(invitation.created && invitation.lifetime && invitation.lifetime !== 0 && invitation.created.getTime() + invitation.lifetime * 1e3 < Date.now());
+};
+var isLegacyInvitationFormat = (invitation) => {
+  return invitation.type === Invitation.Type.MULTIUSE;
 };
-_ts_decorate7([
-  synchronized4
-], SpaceManager.prototype, "open", null);
-_ts_decorate7([
-  synchronized4
-], SpaceManager.prototype, "close", null);
-SpaceManager = _ts_decorate7([
-  trackLeaks3("open", "close")
-], SpaceManager);
 
 export {
-  Buffer,
   codec,
   valueEncoding,
   createMappedFeedWriter,
   SnapshotManager,
   SnapshotStore,
   DocumentsSynchronizer,
-  DataServiceImpl,
-  MetadataStore,
-  hasInvitationExpired,
+  diffCollectionState,
+  LevelDBStorageAdapter,
+  encodingOptions,
+  AutomergeHost,
+  getSpaceKeyFromDoc,
+  deriveCollectionIdFromSpaceId,
+  getSpaceIdFromCollectionId,
+  AuthExtension,
   mapTimeframeToFeedIndexes,
   mapFeedIndexesToTimeframe,
   startAfter,
   TimeframeClock,
   Pipeline,
-  AuthExtension,
   Space,
   createIdFromSpaceKey,
   CredentialRetrieverExtension,
@@ -2361,6 +3835,10 @@ export {
   SpaceProtocol,
   AuthStatus,
   SpaceProtocolSession,
-  SpaceManager
+  SpaceManager,
+  MeshEchoReplicator,
+  DataServiceImpl,
+  MetadataStore,
+  hasInvitationExpired
 };
-//# sourceMappingURL=chunk-UJQ5VS5V.mjs.map
+//# sourceMappingURL=chunk-PEE7MYCZ.mjs.map