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

package/dist/lib/browser/index.mjs

@@ -2,13 +2,15 @@ import "@dxos/node-std/globals";
 import {
   AuthExtension,
   AuthStatus,
-  Buffer,
+  AutomergeHost,
   CredentialRetrieverExtension,
   CredentialServerExtension,
   DataServiceImpl,
   DocumentsSynchronizer,
+  LevelDBStorageAdapter,
   MOCK_AUTH_PROVIDER,
   MOCK_AUTH_VERIFIER,
+  MeshEchoReplicator,
   MetadataStore,
   Pipeline,
   SnapshotManager,
@@ -21,1059 +23,17 @@ import {
   codec,
   createIdFromSpaceKey,
   createMappedFeedWriter,
+  deriveCollectionIdFromSpaceId,
+  diffCollectionState,
+  encodingOptions,
+  getSpaceIdFromCollectionId,
+  getSpaceKeyFromDoc,
   hasInvitationExpired,
   mapFeedIndexesToTimeframe,
   mapTimeframeToFeedIndexes,
   startAfter,
   valueEncoding
-} from "./chunk-UJQ5VS5V.mjs";
-
-// packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts
-import { Event, 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 Resource2, cancelWithContext } from "@dxos/context";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-import { log as log2 } from "@dxos/log";
-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 } from "@dxos/context";
-import { invariant } from "@dxos/invariant";
-import { log } from "@dxos/log";
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts";
-var EchoNetworkAdapter = class extends NetworkAdapter {
-  constructor(_params) {
-    super();
-    this._params = _params;
-    this._replicators = /* @__PURE__ */ new Set();
-    this._connections = /* @__PURE__ */ new Map();
-    this._lifecycleState = LifecycleState.CLOSED;
-    this._connected = new Trigger();
-  }
-  connect(peerId, peerMetadata) {
-    this.peerId = peerId;
-    this.peerMetadata = peerMetadata;
-    this._connected.wake();
-  }
-  send(message) {
-    const connectionEntry = this._connections.get(message.targetId);
-    if (!connectionEntry) {
-      throw new Error("Connection not found.");
-    }
-    connectionEntry.writer.write(message).catch((err) => {
-      if (connectionEntry.isOpen) {
-        log.catch(err, void 0, {
-          F: __dxlog_file,
-          L: 49,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    });
-  }
-  disconnect() {
-  }
-  async open() {
-    if (this._lifecycleState === LifecycleState.OPEN) {
-      return;
-    }
-    this._lifecycleState = LifecycleState.OPEN;
-    log("emit ready", void 0, {
-      F: __dxlog_file,
-      L: 65,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.emit("ready", {
-      network: this
-    });
-  }
-  async close() {
-    if (this._lifecycleState === LifecycleState.CLOSED) {
-      return this;
-    }
-    for (const replicator of this._replicators) {
-      await replicator.disconnect();
-    }
-    this._replicators.clear();
-    this._lifecycleState = LifecycleState.CLOSED;
-  }
-  async whenConnected() {
-    await this._connected.wait({
-      timeout: 1e4
-    });
-  }
-  async addReplicator(replicator) {
-    invariant(this._lifecycleState === LifecycleState.OPEN, void 0, {
-      F: __dxlog_file,
-      L: 91,
-      S: this,
-      A: [
-        "this._lifecycleState === LifecycleState.OPEN",
-        ""
-      ]
-    });
-    invariant(this.peerId, void 0, {
-      F: __dxlog_file,
-      L: 92,
-      S: this,
-      A: [
-        "this.peerId",
-        ""
-      ]
-    });
-    invariant(!this._replicators.has(replicator), void 0, {
-      F: __dxlog_file,
-      L: 93,
-      S: this,
-      A: [
-        "!this._replicators.has(replicator)",
-        ""
-      ]
-    });
-    this._replicators.add(replicator);
-    await replicator.connect({
-      peerId: this.peerId,
-      onConnectionOpen: this._onConnectionOpen.bind(this),
-      onConnectionClosed: this._onConnectionClosed.bind(this),
-      onConnectionAuthScopeChanged: this._onConnectionAuthScopeChanged.bind(this),
-      getContainingSpaceForDocument: this._params.getContainingSpaceForDocument
-    });
-  }
-  async removeReplicator(replicator) {
-    invariant(this._lifecycleState === LifecycleState.OPEN, void 0, {
-      F: __dxlog_file,
-      L: 107,
-      S: this,
-      A: [
-        "this._lifecycleState === LifecycleState.OPEN",
-        ""
-      ]
-    });
-    invariant(this._replicators.has(replicator), void 0, {
-      F: __dxlog_file,
-      L: 108,
-      S: this,
-      A: [
-        "this._replicators.has(replicator)",
-        ""
-      ]
-    });
-    await replicator.disconnect();
-    this._replicators.delete(replicator);
-  }
-  async shouldAdvertise(peerId, params) {
-    const connection = this._connections.get(peerId);
-    if (!connection) {
-      return false;
-    }
-    return connection.connection.shouldAdvertise(params);
-  }
-  _onConnectionOpen(connection) {
-    log("Connection opened", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 123,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    invariant(!this._connections.has(connection.peerId), void 0, {
-      F: __dxlog_file,
-      L: 124,
-      S: this,
-      A: [
-        "!this._connections.has(connection.peerId as PeerId)",
-        ""
-      ]
-    });
-    const reader = connection.readable.getReader();
-    const writer = connection.writable.getWriter();
-    const connectionEntry = {
-      connection,
-      reader,
-      writer,
-      isOpen: true
-    };
-    this._connections.set(connection.peerId, connectionEntry);
-    queueMicrotask(async () => {
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) {
-            break;
-          }
-          this.emit("message", value);
-        }
-      } catch (err) {
-        if (connectionEntry.isOpen) {
-          log.catch(err, void 0, {
-            F: __dxlog_file,
-            L: 143,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        }
-      }
-    });
-    log("emit peer-candidate", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 148,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._emitPeerCandidate(connection);
-  }
-  /**
-  * Trigger doc-synchronizer shared documents set recalculation. Happens on peer-candidate.
-  * TODO(y): replace with a proper API call when sharePolicy update becomes supported by automerge-repo
-  */
-  _onConnectionAuthScopeChanged(connection) {
-    log("Connection auth scope changed", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 157,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const entry = this._connections.get(connection.peerId);
-    invariant(entry, void 0, {
-      F: __dxlog_file,
-      L: 159,
-      S: this,
-      A: [
-        "entry",
-        ""
-      ]
-    });
-    this.emit("peer-disconnected", {
-      peerId: connection.peerId
-    });
-    this._emitPeerCandidate(connection);
-  }
-  _onConnectionClosed(connection) {
-    log("Connection closed", {
-      peerId: connection.peerId
-    }, {
-      F: __dxlog_file,
-      L: 165,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const entry = this._connections.get(connection.peerId);
-    invariant(entry, void 0, {
-      F: __dxlog_file,
-      L: 167,
-      S: this,
-      A: [
-        "entry",
-        ""
-      ]
-    });
-    entry.isOpen = false;
-    this.emit("peer-disconnected", {
-      peerId: connection.peerId
-    });
-    void entry.reader.cancel().catch((err) => log.catch(err, void 0, {
-      F: __dxlog_file,
-      L: 172,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-    void entry.writer.abort().catch((err) => log.catch(err, void 0, {
-      F: __dxlog_file,
-      L: 173,
-      S: this,
-      C: (f, a) => f(...a)
-    }));
-    this._connections.delete(connection.peerId);
-  }
-  _emitPeerCandidate(connection) {
-    this.emit("peer-candidate", {
-      peerId: connection.peerId,
-      peerMetadata: createEchoPeerMetadata()
-    });
-  }
-};
-_ts_decorate([
-  synchronized
-], EchoNetworkAdapter.prototype, "open", null);
-_ts_decorate([
-  synchronized
-], EchoNetworkAdapter.prototype, "close", null);
-_ts_decorate([
-  synchronized
-], EchoNetworkAdapter.prototype, "addReplicator", null);
-_ts_decorate([
-  synchronized
-], EchoNetworkAdapter.prototype, "removeReplicator", null);
-var createEchoPeerMetadata = () => ({
-  // TODO(dmaretskyi): Refactor this.
-  dxos_peerSource: "EchoNetworkAdapter"
-});
-var isEchoPeerMetadata = (metadata) => metadata?.dxos_peerSource === "EchoNetworkAdapter";
-
-// packages/core/echo/echo-pipeline/src/automerge/heads-store.ts
-import { headsEncoding } from "@dxos/indexing";
-var HeadsStore = class {
-  constructor({ db }) {
-    this._db = db;
-  }
-  setHeads(documentId, heads, batch) {
-    batch.put(documentId, heads, {
-      sublevel: this._db,
-      keyEncoding: "utf8",
-      valueEncoding: headsEncoding
-    });
-  }
-  async getHeads(documentId) {
-    try {
-      return await this._db.get(documentId, {
-        keyEncoding: "utf8",
-        valueEncoding: headsEncoding
-      });
-    } catch (err) {
-      if (err.notFound) {
-        return void 0;
-      }
-      throw err;
-    }
-  }
-};
-
-// packages/core/echo/echo-pipeline/src/automerge/leveldb-storage-adapter.ts
-import { LifecycleState as LifecycleState2, Resource } from "@dxos/context";
-var LevelDBStorageAdapter = class extends Resource {
-  constructor(_params) {
-    super();
-    this._params = _params;
-  }
-  async load(keyArray) {
-    try {
-      if (this._lifecycleState !== LifecycleState2.OPEN) {
-        return void 0;
-      }
-      return await this._params.db.get(keyArray, {
-        ...encodingOptions
-      });
-    } catch (err) {
-      if (isLevelDbNotFoundError(err)) {
-        return void 0;
-      }
-      throw err;
-    }
-  }
-  async save(keyArray, binary) {
-    if (this._lifecycleState !== LifecycleState2.OPEN) {
-      return void 0;
-    }
-    const batch = this._params.db.batch();
-    await this._params.callbacks?.beforeSave?.({
-      path: keyArray,
-      batch
-    });
-    batch.put(keyArray, Buffer.from(binary), {
-      ...encodingOptions
-    });
-    await batch.write();
-    await this._params.callbacks?.afterSave?.(keyArray);
-  }
-  async remove(keyArray) {
-    if (this._lifecycleState !== LifecycleState2.OPEN) {
-      return void 0;
-    }
-    await this._params.db.del(keyArray, {
-      ...encodingOptions
-    });
-  }
-  async loadRange(keyPrefix) {
-    if (this._lifecycleState !== LifecycleState2.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 !== LifecycleState2.OPEN) {
-      return void 0;
-    }
-    const batch = this._params.db.batch();
-    for await (const [key] of this._params.db.iterator({
-      gte: keyPrefix,
-      lte: [
-        ...keyPrefix,
-        "\uFFFF"
-      ],
-      ...encodingOptions
-    })) {
-      batch.del(key, {
-        ...encodingOptions
-      });
-    }
-    await batch.write();
-  }
-};
-var keyEncoder = {
-  encode: (key) => Buffer.from(key.map((k) => k.replaceAll("%", "%25").replaceAll("-", "%2D")).join("-")),
-  decode: (key) => Buffer.from(key).toString().split("-").map((k) => k.replaceAll("%2D", "-").replaceAll("%25", "%")),
-  format: "buffer"
-};
-var encodingOptions = {
-  keyEncoding: keyEncoder,
-  valueEncoding: "buffer"
-};
-var isLevelDbNotFoundError = (err) => err.code === "LEVEL_NOT_FOUND";
-
-// packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts
-function _ts_decorate2(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
-var AutomergeHost = class extends Resource2 {
-  constructor({ db, indexMetadataStore }) {
-    super();
-    this._echoNetworkAdapter = new EchoNetworkAdapter({
-      getContainingSpaceForDocument: this._getContainingSpaceForDocument.bind(this)
-    });
-    this._db = db;
-    this._storage = new LevelDBStorageAdapter({
-      db: db.sublevel("automerge"),
-      callbacks: {
-        beforeSave: async (params) => this._beforeSave(params),
-        afterSave: async () => this._afterSave()
-      }
-    });
-    this._headsStore = new HeadsStore({
-      db: db.sublevel("heads")
-    });
-    this._indexMetadataStore = indexMetadataStore;
-  }
-  async _open() {
-    this._peerId = `host-${PublicKey.random().toHex()}`;
-    await this._storage.open?.();
-    this._repo = new Repo({
-      peerId: this._peerId,
-      sharePolicy: this._sharePolicy.bind(this),
-      storage: this._storage,
-      network: [
-        // Upstream swarm.
-        this._echoNetworkAdapter
-      ]
-    });
-    await this._echoNetworkAdapter.open();
-    await this._echoNetworkAdapter.whenConnected();
-  }
-  async _close() {
-    await this._storage.close?.();
-    await this._echoNetworkAdapter.close();
-    await this._ctx.dispose();
-  }
-  /**
-  * @deprecated To be abstracted away.
-  */
-  get repo() {
-    return this._repo;
-  }
-  get loadedDocsCount() {
-    return Object.keys(this._repo.handles).length;
-  }
-  async addReplicator(replicator) {
-    await this._echoNetworkAdapter.addReplicator(replicator);
-  }
-  async removeReplicator(replicator) {
-    await this._echoNetworkAdapter.removeReplicator(replicator);
-  }
-  /**
-  * Loads the document handle from the repo and waits for it to be ready.
-  */
-  async loadDoc(ctx, documentId, opts) {
-    let handle;
-    if (typeof documentId === "string") {
-      handle = this._repo.handles[documentId];
-    }
-    if (!handle) {
-      handle = this._repo.find(documentId);
-    }
-    if (!handle.isReady()) {
-      if (!opts?.timeout) {
-        await cancelWithContext(ctx, handle.whenReady());
-      } else {
-        await cancelWithContext(ctx, asyncTimeout(handle.whenReady(), opts.timeout));
-      }
-    }
-    return handle;
-  }
-  /**
-  * Create new persisted document.
-  */
-  createDoc(initialValue, opts) {
-    if (opts?.preserveHistory) {
-      if (!isAutomerge(initialValue)) {
-        throw new TypeError("Initial value must be an Automerge document");
-      }
-      return this._repo.import(save(initialValue));
-    } else {
-      return this._repo.create(initialValue);
-    }
-  }
-  async waitUntilHeadsReplicated(heads) {
-    await Promise.all(heads.entries?.map(async ({ documentId, heads: heads2 }) => {
-      if (!heads2 || heads2.length === 0) {
-        return;
-      }
-      const currentHeads = this.getHeads(documentId);
-      if (currentHeads !== null && headsEquals(currentHeads, heads2)) {
-        return;
-      }
-      const handle = await this.loadDoc(Context.default(void 0, {
-        F: __dxlog_file2,
-        L: 189
-      }), documentId);
-      await waitForHeads(handle, heads2);
-    }) ?? []);
-    await this._repo.flush(heads.entries?.map((entry) => entry.documentId) ?? []);
-  }
-  async reIndexHeads(documentIds) {
-    for (const documentId of documentIds) {
-      log2.info("re-indexing heads for document", {
-        documentId
-      }, {
-        F: __dxlog_file2,
-        L: 200,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const handle = this._repo.find(documentId);
-      await handle.whenReady([
-        "ready",
-        "requesting"
-      ]);
-      if (handle.inState([
-        "requesting"
-      ])) {
-        log2.warn("document is not available locally, skipping", {
-          documentId
-        }, {
-          F: __dxlog_file2,
-          L: 204,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        continue;
-      }
-      const doc = handle.docSync();
-      invariant2(doc, void 0, {
-        F: __dxlog_file2,
-        L: 209,
-        S: this,
-        A: [
-          "doc",
-          ""
-        ]
-      });
-      const heads = getHeads(doc);
-      const batch = this._db.batch();
-      this._headsStore.setHeads(documentId, heads, batch);
-      await batch.write();
-    }
-    log2.info("done re-indexing heads", void 0, {
-      F: __dxlog_file2,
-      L: 216,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
-  // Hosts, running in the worker, don't share documents unless requested by other peers.
-  // NOTE: If both peers return sharePolicy=false the replication will not happen
-  // https://github.com/automerge/automerge-repo/pull/292
-  async _sharePolicy(peerId, documentId) {
-    if (peerId.startsWith("client-")) {
-      return false;
-    }
-    if (!documentId) {
-      return false;
-    }
-    const peerMetadata = this.repo.peerMetadataByPeerId[peerId];
-    if (isEchoPeerMetadata(peerMetadata)) {
-      return this._echoNetworkAdapter.shouldAdvertise(peerId, {
-        documentId
-      });
-    }
-    return false;
-  }
-  async _beforeSave({ path, batch }) {
-    const handle = this._repo.handles[path[0]];
-    if (!handle) {
-      return;
-    }
-    const doc = handle.docSync();
-    if (!doc) {
-      return;
-    }
-    const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
-    const heads = getHeads(doc);
-    this._headsStore.setHeads(handle.documentId, heads, batch);
-    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);
-  }
-  /**
-  * Called by AutomergeStorageAdapter after levelDB batch commit.
-  */
-  async _afterSave() {
-    this._indexMetadataStore.notifyMarkedDirty();
-  }
-  _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}`;
-        }
-      })
-    }));
-  }
-  _automergePeers() {
-    return this._repo.peers;
-  }
-  async _getContainingSpaceForDocument(documentId) {
-    const doc = this._repo.handles[documentId]?.docSync();
-    if (!doc) {
-      return null;
-    }
-    const spaceKeyHex = getSpaceKeyFromDoc(doc);
-    if (!spaceKeyHex) {
-      return null;
-    }
-    return PublicKey.from(spaceKeyHex);
-  }
-  /**
-  * Flush documents to disk.
-  */
-  async flush({ documentIds } = {}) {
-    await this._repo.flush(documentIds);
-  }
-  async getHeads(documentId) {
-    const handle = this._repo.handles[documentId];
-    if (handle) {
-      const doc = handle.docSync();
-      if (!doc) {
-        return void 0;
-      }
-      return getHeads(doc);
-    } else {
-      return this._headsStore.getHeads(documentId);
-    }
-  }
-};
-_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 Event.wrap(handle, "change").waitForCondition(() => {
-    for (const changeHash of unavailableHeads.values()) {
-      if (changeIsPresentInDoc(handle.docSync(), changeHash)) {
-        unavailableHeads.delete(changeHash);
-      }
-    }
-    return unavailableHeads.size === 0;
-  });
-};
-var changeIsPresentInDoc = (doc, changeHash) => {
-  return !!getBackend(doc).getChangeByHash(changeHash);
-};
-
-// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts
-import { invariant as invariant4 } from "@dxos/invariant";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log4 } from "@dxos/log";
-import { ComplexMap, ComplexSet, defaultMap } 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 Resource3 } from "@dxos/context";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { log as log3 } from "@dxos/log";
-import { AutomergeReplicator } from "@dxos/teleport-extension-automerge-replicator";
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator-connection.ts";
-var DEFAULT_FACTORY = (params) => new AutomergeReplicator(...params);
-var MeshReplicatorConnection = class extends Resource3 {
-  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) => {
-        invariant3(this._isEnabled, "Writing to a disabled connection", {
-          F: __dxlog_file3,
-          L: 47,
-          S: this,
-          A: [
-            "this._isEnabled",
-            "'Writing to a disabled connection'"
-          ]
-        });
-        try {
-          await this.replicatorExtension.sendSyncMessage({
-            payload: cbor.encode(message)
-          });
-        } catch (err) {
-          controller.error(err);
-          this._disconnectIfEnabled();
-        }
-      }
-    });
-    const createAutomergeReplicator = this._params.replicatorFactory ?? DEFAULT_FACTORY;
-    this.replicatorExtension = createAutomergeReplicator([
-      {
-        peerId: this._params.ownPeerId
-      },
-      {
-        onStartReplication: async (info, remotePeerId) => {
-          this.remoteDeviceKey = remotePeerId;
-          this._remotePeerId = info.id;
-          log3("onStartReplication", {
-            id: info.id,
-            thisPeerId: this.peerId,
-            remotePeerId: remotePeerId.toHex()
-          }, {
-            F: __dxlog_file3,
-            L: 81,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._params.onRemoteConnected();
-        },
-        onSyncMessage: async ({ payload }) => {
-          if (!this._isEnabled) {
-            return;
-          }
-          const message = cbor.decode(payload);
-          readableStreamController.enqueue(message);
-        },
-        onClose: async () => {
-          this._disconnectIfEnabled();
-        }
-      }
-    ]);
-  }
-  _disconnectIfEnabled() {
-    if (this._isEnabled) {
-      this._params.onRemoteDisconnected();
-    }
-  }
-  get peerId() {
-    invariant3(this._remotePeerId != null, "Remote peer has not connected yet.", {
-      F: __dxlog_file3,
-      L: 107,
-      S: this,
-      A: [
-        "this._remotePeerId != null",
-        "'Remote peer has not connected yet.'"
-      ]
-    });
-    return this._remotePeerId;
-  }
-  async shouldAdvertise(params) {
-    return this._params.shouldAdvertise(params);
-  }
-  /**
-  * Start exchanging messages with the remote peer.
-  * Call after the remote peer has connected.
-  */
-  enable() {
-    invariant3(this._remotePeerId != null, "Remote peer has not connected yet.", {
-      F: __dxlog_file3,
-      L: 120,
-      S: this,
-      A: [
-        "this._remotePeerId != null",
-        "'Remote peer has not connected yet.'"
-      ]
-    });
-    this._isEnabled = true;
-  }
-  /**
-  * Stop exchanging messages with the remote peer.
-  */
-  disable() {
-    this._isEnabled = false;
-  }
-};
-
-// packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-echo-replicator.ts";
-var MeshEchoReplicator = class {
-  constructor() {
-    this._connections = /* @__PURE__ */ new Set();
-    /**
-    * Using automerge peerId as a key.
-    */
-    this._connectionsPerPeer = /* @__PURE__ */ new Map();
-    /**
-    * spaceKey -> deviceKey[]
-    */
-    this._authorizedDevices = new ComplexMap(PublicKey2.hash);
-    this._context = null;
-  }
-  async connect(context) {
-    this._context = context;
-  }
-  async disconnect() {
-    for (const connection of this._connectionsPerPeer.values()) {
-      this._context?.onConnectionClosed(connection);
-    }
-    for (const connection of this._connections) {
-      await connection.close();
-    }
-    this._connections.clear();
-    this._connectionsPerPeer.clear();
-    this._context = null;
-  }
-  createExtension(extensionFactory) {
-    invariant4(this._context, void 0, {
-      F: __dxlog_file4,
-      L: 54,
-      S: this,
-      A: [
-        "this._context",
-        ""
-      ]
-    });
-    const connection = new MeshReplicatorConnection({
-      ownPeerId: this._context.peerId,
-      replicatorFactory: extensionFactory,
-      onRemoteConnected: async () => {
-        log4("onRemoteConnected", {
-          peerId: connection.peerId
-        }, {
-          F: __dxlog_file4,
-          L: 60,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        invariant4(this._context, void 0, {
-          F: __dxlog_file4,
-          L: 61,
-          S: this,
-          A: [
-            "this._context",
-            ""
-          ]
-        });
-        if (this._connectionsPerPeer.has(connection.peerId)) {
-          this._context.onConnectionAuthScopeChanged(connection);
-        } else {
-          this._connectionsPerPeer.set(connection.peerId, connection);
-          this._context.onConnectionOpen(connection);
-          connection.enable();
-        }
-      },
-      onRemoteDisconnected: async () => {
-        log4("onRemoteDisconnected", {
-          peerId: connection.peerId
-        }, {
-          F: __dxlog_file4,
-          L: 72,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._context?.onConnectionClosed(connection);
-        this._connectionsPerPeer.delete(connection.peerId);
-        connection.disable();
-        this._connections.delete(connection);
-      },
-      shouldAdvertise: async (params) => {
-        log4("shouldAdvertise", {
-          peerId: connection.peerId,
-          documentId: params.documentId
-        }, {
-          F: __dxlog_file4,
-          L: 79,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        invariant4(this._context, void 0, {
-          F: __dxlog_file4,
-          L: 80,
-          S: this,
-          A: [
-            "this._context",
-            ""
-          ]
-        });
-        try {
-          const spaceKey = await this._context.getContainingSpaceForDocument(params.documentId);
-          if (!spaceKey) {
-            log4("space key not found for share policy check", {
-              peerId: connection.peerId,
-              documentId: params.documentId
-            }, {
-              F: __dxlog_file4,
-              L: 84,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return false;
-          }
-          const authorizedDevices = this._authorizedDevices.get(spaceKey);
-          if (!connection.remoteDeviceKey) {
-            log4("device key not found for share policy check", {
-              peerId: connection.peerId,
-              documentId: params.documentId
-            }, {
-              F: __dxlog_file4,
-              L: 94,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            return false;
-          }
-          const isAuthorized = authorizedDevices?.has(connection.remoteDeviceKey) ?? false;
-          log4("share policy check", {
-            localPeer: this._context.peerId,
-            remotePeer: connection.peerId,
-            documentId: params.documentId,
-            deviceKey: connection.remoteDeviceKey,
-            spaceKey,
-            isAuthorized
-          }, {
-            F: __dxlog_file4,
-            L: 102,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          return isAuthorized;
-        } catch (err) {
-          log4.catch(err, void 0, {
-            F: __dxlog_file4,
-            L: 112,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          return false;
-        }
-      }
-    });
-    this._connections.add(connection);
-    return connection.replicatorExtension;
-  }
-  authorizeDevice(spaceKey, deviceKey) {
-    log4("authorizeDevice", {
-      spaceKey,
-      deviceKey
-    }, {
-      F: __dxlog_file4,
-      L: 123,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    defaultMap(this._authorizedDevices, spaceKey, () => new ComplexSet(PublicKey2.hash)).add(deviceKey);
-    for (const connection of this._connections) {
-      if (connection.remoteDeviceKey && connection.remoteDeviceKey.equals(deviceKey)) {
-        if (this._connectionsPerPeer.has(connection.peerId)) {
-          this._context?.onConnectionAuthScopeChanged(connection);
-        }
-      }
-    }
-  }
-};
+} from "./chunk-6MJEONOX.mjs";
 export {
   AuthExtension,
   AuthStatus,
@@ -1098,7 +58,10 @@ export {
   codec,
   createIdFromSpaceKey,
   createMappedFeedWriter,
+  deriveCollectionIdFromSpaceId,
+  diffCollectionState,
   encodingOptions,
+  getSpaceIdFromCollectionId,
   getSpaceKeyFromDoc,
   hasInvitationExpired,
   mapFeedIndexesToTimeframe,