@dxos/echo-pipeline 0.4.8-main.c67d72c → 0.4.8-main.cd60bd2

package/dist/lib/node/index.cjs

@@ -18,38 +18,655 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  AuthExtension: () => import_chunk_LD4R726W.AuthExtension,
-  AuthStatus: () => import_chunk_LD4R726W.AuthStatus,
-  AutomergeHost: () => import_chunk_LD4R726W.AutomergeHost,
-  AutomergeStorageAdapter: () => import_chunk_LD4R726W.AutomergeStorageAdapter,
-  DataPipeline: () => import_chunk_LD4R726W.DataPipeline,
-  DataServiceHost: () => import_chunk_LD4R726W.DataServiceHost,
-  DataServiceImpl: () => import_chunk_LD4R726W.DataServiceImpl,
-  DataServiceSubscriptions: () => import_chunk_LD4R726W.DataServiceSubscriptions,
-  DatabaseHost: () => import_chunk_LD4R726W.DatabaseHost,
-  LocalHostNetworkAdapter: () => import_chunk_LD4R726W.LocalHostNetworkAdapter,
-  MOCK_AUTH_PROVIDER: () => import_chunk_LD4R726W.MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER: () => import_chunk_LD4R726W.MOCK_AUTH_VERIFIER,
-  MeshNetworkAdapter: () => import_chunk_LD4R726W.MeshNetworkAdapter,
-  MetadataStore: () => import_chunk_LD4R726W.MetadataStore,
-  Pipeline: () => import_chunk_LD4R726W.Pipeline,
-  SnapshotManager: () => import_chunk_LD4R726W.SnapshotManager,
-  SnapshotStore: () => import_chunk_LD4R726W.SnapshotStore,
-  Space: () => import_chunk_LD4R726W.Space,
-  SpaceManager: () => import_chunk_LD4R726W.SpaceManager,
-  SpaceProtocol: () => import_chunk_LD4R726W.SpaceProtocol,
-  SpaceProtocolSession: () => import_chunk_LD4R726W.SpaceProtocolSession,
-  TimeframeClock: () => import_chunk_LD4R726W.TimeframeClock,
-  codec: () => import_chunk_LD4R726W.codec,
-  createMappedFeedWriter: () => import_chunk_LD4R726W.createMappedFeedWriter,
-  getSpaceKeyFromDoc: () => import_chunk_LD4R726W.getSpaceKeyFromDoc,
-  mapFeedIndexesToTimeframe: () => import_chunk_LD4R726W.mapFeedIndexesToTimeframe,
-  mapTimeframeToFeedIndexes: () => import_chunk_LD4R726W.mapTimeframeToFeedIndexes,
-  startAfter: () => import_chunk_LD4R726W.startAfter,
-  valueEncoding: () => import_chunk_LD4R726W.valueEncoding
+  AuthExtension: () => import_chunk_U6J2HC4T.AuthExtension,
+  AuthStatus: () => import_chunk_U6J2HC4T.AuthStatus,
+  AutomergeHost: () => AutomergeHost,
+  AutomergeStorageAdapter: () => AutomergeStorageAdapter,
+  DataPipeline: () => import_chunk_U6J2HC4T.DataPipeline,
+  DataServiceHost: () => import_chunk_U6J2HC4T.DataServiceHost,
+  DataServiceImpl: () => import_chunk_U6J2HC4T.DataServiceImpl,
+  DataServiceSubscriptions: () => import_chunk_U6J2HC4T.DataServiceSubscriptions,
+  DatabaseHost: () => import_chunk_U6J2HC4T.DatabaseHost,
+  LocalHostNetworkAdapter: () => LocalHostNetworkAdapter,
+  MOCK_AUTH_PROVIDER: () => import_chunk_U6J2HC4T.MOCK_AUTH_PROVIDER,
+  MOCK_AUTH_VERIFIER: () => import_chunk_U6J2HC4T.MOCK_AUTH_VERIFIER,
+  MeshNetworkAdapter: () => MeshNetworkAdapter,
+  MetadataStore: () => import_chunk_U6J2HC4T.MetadataStore,
+  Pipeline: () => import_chunk_U6J2HC4T.Pipeline,
+  SnapshotManager: () => import_chunk_U6J2HC4T.SnapshotManager,
+  SnapshotStore: () => import_chunk_U6J2HC4T.SnapshotStore,
+  Space: () => import_chunk_U6J2HC4T.Space,
+  SpaceManager: () => import_chunk_U6J2HC4T.SpaceManager,
+  SpaceProtocol: () => import_chunk_U6J2HC4T.SpaceProtocol,
+  SpaceProtocolSession: () => import_chunk_U6J2HC4T.SpaceProtocolSession,
+  TimeframeClock: () => import_chunk_U6J2HC4T.TimeframeClock,
+  codec: () => import_chunk_U6J2HC4T.codec,
+  createMappedFeedWriter: () => import_chunk_U6J2HC4T.createMappedFeedWriter,
+  getSpaceKeyFromDoc: () => getSpaceKeyFromDoc,
+  mapFeedIndexesToTimeframe: () => import_chunk_U6J2HC4T.mapFeedIndexesToTimeframe,
+  mapTimeframeToFeedIndexes: () => import_chunk_U6J2HC4T.mapTimeframeToFeedIndexes,
+  startAfter: () => import_chunk_U6J2HC4T.startAfter,
+  valueEncoding: () => import_chunk_U6J2HC4T.valueEncoding
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_LD4R726W = require("./chunk-LD4R726W.cjs");
+var import_chunk_U6J2HC4T = require("./chunk-U6J2HC4T.cjs");
+var import_automerge = require("@dxos/automerge/automerge");
+var import_automerge_repo = require("@dxos/automerge/automerge-repo");
+var import_automerge_repo_storage_indexeddb = require("@dxos/automerge/automerge-repo-storage-indexeddb");
+var import_context = require("@dxos/context");
+var import_keys = require("@dxos/keys");
+var import_log = require("@dxos/log");
+var import_protocols = require("@dxos/protocols");
+var import_random_access_storage = require("@dxos/random-access-storage");
+var import_tracing = require("@dxos/tracing");
+var import_util = require("@dxos/util");
+var import_util2 = require("@dxos/util");
+var import_async = require("@dxos/async");
+var import_automerge_repo2 = require("@dxos/automerge/automerge-repo");
+var import_codec_protobuf = require("@dxos/codec-protobuf");
+var import_invariant = require("@dxos/invariant");
+var import_log2 = require("@dxos/log");
+var import_async2 = require("@dxos/async");
+var import_automerge_repo3 = require("@dxos/automerge/automerge-repo");
+var import_invariant2 = require("@dxos/invariant");
+var import_log3 = require("@dxos/log");
+var import_teleport_extension_automerge_replicator = require("@dxos/teleport-extension-automerge-replicator");
+var AutomergeStorageAdapter = class {
+  constructor(_directory) {
+    this._directory = _directory;
+    this._state = "opened";
+  }
+  async load(key) {
+    if (this._state !== "opened") {
+      return void 0;
+    }
+    const filename = this._getFilename(key);
+    const file = this._directory.getOrCreateFile(filename);
+    const { size } = await file.stat();
+    if (!size || size === 0) {
+      return void 0;
+    }
+    const buffer = await file.read(0, size);
+    return (0, import_util2.bufferToArray)(buffer);
+  }
+  async save(key, data) {
+    if (this._state !== "opened") {
+      return void 0;
+    }
+    const filename = this._getFilename(key);
+    const file = this._directory.getOrCreateFile(filename);
+    await file.write(0, (0, import_util2.arrayToBuffer)(data));
+    await file.truncate?.(data.length);
+    await file.flush?.();
+  }
+  async remove(key) {
+    if (this._state !== "opened") {
+      return void 0;
+    }
+    const filename = this._getFilename(key);
+    const file = this._directory.getOrCreateFile(filename);
+    await file.destroy();
+  }
+  async loadRange(keyPrefix) {
+    if (this._state !== "opened") {
+      return [];
+    }
+    const filename = this._getFilename(keyPrefix);
+    const entries = await this._directory.list();
+    return Promise.all(entries.filter((entry) => entry.startsWith(filename)).map(async (entry) => {
+      const file = this._directory.getOrCreateFile(entry);
+      const { size } = await file.stat();
+      const buffer = await file.read(0, size);
+      return {
+        key: this._getKeyFromFilename(entry),
+        data: (0, import_util2.bufferToArray)(buffer)
+      };
+    }));
+  }
+  async removeRange(keyPrefix) {
+    if (this._state !== "opened") {
+      return void 0;
+    }
+    const filename = this._getFilename(keyPrefix);
+    const entries = await this._directory.list();
+    await Promise.all(entries.filter((entry) => entry.startsWith(filename)).map(async (entry) => {
+      const file = this._directory.getOrCreateFile(entry);
+      await file.destroy();
+    }));
+  }
+  async close() {
+    this._state = "closed";
+  }
+  _getFilename(key) {
+    return key.map((k) => k.replaceAll("%", "%25").replaceAll("-", "%2D")).join("-");
+  }
+  _getKeyFromFilename(filename) {
+    return filename.split("-").map((k) => k.replaceAll("%2D", "-").replaceAll("%25", "%"));
+  }
+};
+var AutomergeStorageWrapper = class {
+  constructor({ storage, callbacks }) {
+    this._storage = storage;
+    this._callbacks = callbacks;
+  }
+  async load(key) {
+    return this._storage.load(key);
+  }
+  async save(key, value) {
+    await this._callbacks.beforeSave?.(key);
+    await this._storage.save(key, value);
+    await this._callbacks.afterSave?.(key);
+  }
+  async remove(key) {
+    return this._storage.remove(key);
+  }
+  async loadRange(keyPrefix) {
+    return this._storage.loadRange(keyPrefix);
+  }
+  async removeRange(keyPrefix) {
+    return this._storage.removeRange(keyPrefix);
+  }
+  async close() {
+    if (this._storage instanceof AutomergeStorageAdapter) {
+      return this._storage.close();
+    }
+  }
+};
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/local-host-network-adapter.ts";
+var LocalHostNetworkAdapter = class extends import_automerge_repo2.NetworkAdapter {
+  constructor() {
+    super(...arguments);
+    this._peers = /* @__PURE__ */ new Map();
+    this._connected = new import_async.Trigger();
+  }
+  /**
+  * Emits `ready` event. That signals to `Repo` that it can start using the adapter.
+  */
+  ready() {
+    this.emit("ready", {
+      network: this
+    });
+  }
+  connect(peerId) {
+    this.peerId = peerId;
+    this._connected.wake();
+  }
+  send(message) {
+    const peer = this._peers.get(message.targetId);
+    (0, import_invariant.invariant)(peer, "Peer not found.", {
+      F: __dxlog_file,
+      L: 45,
+      S: this,
+      A: [
+        "peer",
+        "'Peer not found.'"
+      ]
+    });
+    peer.send(message);
+  }
+  async close() {
+    this._peers.forEach((peer) => peer.disconnect());
+    this.emit("close");
+  }
+  disconnect() {
+  }
+  syncRepo({ id, syncMessage }) {
+    const peerId = this._getPeerId(id);
+    return new import_codec_protobuf.Stream(({ next, close }) => {
+      (0, import_invariant.invariant)(!this._peers.has(peerId), "Peer already connected.", {
+        F: __dxlog_file,
+        L: 63,
+        S: this,
+        A: [
+          "!this._peers.has(peerId)",
+          "'Peer already connected.'"
+        ]
+      });
+      this._peers.set(peerId, {
+        connected: true,
+        send: (message) => {
+          next({
+            syncMessage: import_automerge_repo2.cbor.encode(message)
+          });
+        },
+        disconnect: () => {
+          this._peers.delete(peerId);
+          close();
+          this.emit("peer-disconnected", {
+            peerId
+          });
+        }
+      });
+      this._connected.wait({
+        timeout: 1e3
+      }).then(() => {
+        this.emit("peer-candidate", {
+          peerMetadata: {},
+          peerId
+        });
+      }).catch((err) => import_log2.log.catch(err, void 0, {
+        F: __dxlog_file,
+        L: 88,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    });
+  }
+  async sendSyncMessage({ id, syncMessage }) {
+    await this._connected.wait({
+      timeout: 1e3
+    });
+    const message = import_automerge_repo2.cbor.decode(syncMessage);
+    this.emit("message", message);
+  }
+  async getHostInfo() {
+    await this._connected.wait({
+      timeout: 1e3
+    });
+    (0, import_invariant.invariant)(this.peerId, "Peer id not set.", {
+      F: __dxlog_file,
+      L: 100,
+      S: this,
+      A: [
+        "this.peerId",
+        "'Peer id not set.'"
+      ]
+    });
+    return {
+      peerId: this.peerId
+    };
+  }
+  _getPeerId(id) {
+    return id;
+  }
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-network-adapter.ts";
+var MeshNetworkAdapter = class extends import_automerge_repo3.NetworkAdapter {
+  constructor() {
+    super(...arguments);
+    this._extensions = /* @__PURE__ */ new Map();
+    this._connected = new import_async2.Trigger();
+  }
+  /**
+  * Emits `ready` event. That signals to `Repo` that it can start using the adapter.
+  */
+  ready() {
+    this.emit("ready", {
+      network: this
+    });
+  }
+  connect(peerId) {
+    this.peerId = peerId;
+    this._connected.wake();
+  }
+  send(message) {
+    const receiverId = message.targetId;
+    const extension = this._extensions.get(receiverId);
+    (0, import_invariant2.invariant)(extension, "Extension not found.", {
+      F: __dxlog_file2,
+      L: 38,
+      S: this,
+      A: [
+        "extension",
+        "'Extension not found.'"
+      ]
+    });
+    extension.sendSyncMessage({
+      payload: import_automerge_repo3.cbor.encode(message)
+    }).catch((err) => import_log3.log.catch(err, void 0, {
+      F: __dxlog_file2,
+      L: 39,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+  }
+  disconnect() {
+  }
+  createExtension() {
+    (0, import_invariant2.invariant)(this.peerId, "Peer id not set.", {
+      F: __dxlog_file2,
+      L: 47,
+      S: this,
+      A: [
+        "this.peerId",
+        "'Peer id not set.'"
+      ]
+    });
+    let peerInfo;
+    const extension = new import_teleport_extension_automerge_replicator.AutomergeReplicator({
+      peerId: this.peerId
+    }, {
+      onStartReplication: async (info, remotePeerId) => {
+        await this._connected.wait();
+        (0, import_log3.log)("onStartReplication", {
+          id: info.id,
+          thisPeerId: this.peerId,
+          remotePeerId: remotePeerId.toHex()
+        }, {
+          F: __dxlog_file2,
+          L: 70,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (!this._extensions.has(info.id)) {
+          peerInfo = info;
+          this._extensions.set(info.id, extension);
+          (0, import_log3.log)("peer-candidate", {
+            id: info.id,
+            thisPeerId: this.peerId,
+            remotePeerId: remotePeerId.toHex()
+          }, {
+            F: __dxlog_file2,
+            L: 76,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this.emit("peer-candidate", {
+            // TODO(mykola): Hack, stop abusing `peerMetadata` field.
+            peerMetadata: {
+              dxos_deviceKey: remotePeerId.toHex()
+            },
+            peerId: info.id
+          });
+        }
+      },
+      onSyncMessage: async ({ payload }) => {
+        if (!peerInfo) {
+          return;
+        }
+        const message = import_automerge_repo3.cbor.decode(payload);
+        this.emit("message", message);
+      },
+      onClose: async () => {
+        if (!peerInfo) {
+          return;
+        }
+        this.emit("peer-disconnected", {
+          peerId: peerInfo.id
+        });
+        this._extensions.delete(peerInfo.id);
+      }
+    });
+    return extension;
+  }
+};
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
+var AutomergeHost = class {
+  constructor({ directory, metadata }) {
+    this._ctx = new import_context.Context();
+    this._authorizedDevices = new import_util.ComplexMap(import_keys.PublicKey.hash);
+    this._updatingMetadata = /* @__PURE__ */ new Map();
+    this._requestedDocs = /* @__PURE__ */ new Set();
+    this._metadata = metadata;
+    this._meshNetwork = new MeshNetworkAdapter();
+    this._clientNetwork = new LocalHostNetworkAdapter();
+    this._storage = new AutomergeStorageWrapper({
+      storage: (
+        // TODO(mykola): Delete specific handling of IDB storage.
+        directory.type === import_random_access_storage.StorageType.IDB ? new import_automerge_repo_storage_indexeddb.IndexedDBStorageAdapter(directory.path, "data") : new AutomergeStorageAdapter(directory)
+      ),
+      callbacks: {
+        beforeSave: (params) => this._beforeSave(params)
+      }
+    });
+    this._peerId = `host-${import_keys.PublicKey.random().toHex()}`;
+    this._repo = new import_automerge_repo.Repo({
+      peerId: this._peerId,
+      network: [
+        this._clientNetwork,
+        this._meshNetwork
+      ],
+      storage: this._storage,
+      // TODO(dmaretskyi): Share based on HALO permissions and space affinity.
+      // Hosts, running in the worker, don't share documents unless requested by other peers.
+      sharePolicy: async (peerId, documentId) => {
+        if (peerId.startsWith("client-")) {
+          return false;
+        }
+        if (!documentId) {
+          return false;
+        }
+        const doc = this._repo.handles[documentId]?.docSync();
+        if (!doc) {
+          const isRequested = this._requestedDocs.has(`automerge:${documentId}`);
+          (0, import_log.log)("doc share policy check", {
+            peerId,
+            documentId,
+            isRequested
+          }, {
+            F: __dxlog_file3,
+            L: 96,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return isRequested;
+        }
+        try {
+          const spaceKey = getSpaceKeyFromDoc(doc);
+          if (!spaceKey) {
+            (0, import_log.log)("space key not found for share policy check", {
+              peerId,
+              documentId
+            }, {
+              F: __dxlog_file3,
+              L: 103,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return false;
+          }
+          const authorizedDevices = this._authorizedDevices.get(import_keys.PublicKey.from(spaceKey));
+          const deviceKeyHex = this.repo.peerMetadataByPeerId[peerId]?.dxos_deviceKey;
+          if (!deviceKeyHex) {
+            (0, import_log.log)("device key not found for share policy check", {
+              peerId,
+              documentId
+            }, {
+              F: __dxlog_file3,
+              L: 112,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            return false;
+          }
+          const deviceKey = import_keys.PublicKey.from(deviceKeyHex);
+          const isAuthorized = authorizedDevices?.has(deviceKey) ?? false;
+          (0, import_log.log)("share policy check", {
+            localPeer: this._peerId,
+            remotePeer: peerId,
+            documentId,
+            deviceKey,
+            spaceKey,
+            isAuthorized
+          }, {
+            F: __dxlog_file3,
+            L: 118,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return isAuthorized;
+        } catch (err) {
+          import_log.log.catch(err, void 0, {
+            F: __dxlog_file3,
+            L: 128,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return false;
+        }
+      }
+    });
+    this._clientNetwork.ready();
+    this._meshNetwork.ready();
+    {
+      const listener = ({ handle }) => this._onDocument(handle);
+      this._repo.on("document", listener);
+      this._ctx.onDispose(() => {
+        this._repo.off("document", listener);
+      });
+    }
+  }
+  get repo() {
+    return this._repo;
+  }
+  async _beforeSave(path) {
+    const id = path[0];
+    if (this._updatingMetadata.has(id)) {
+      return this._updatingMetadata.get(id);
+    }
+  }
+  _onDocument(handle) {
+    const listener = (event) => this._onUpdate(event);
+    handle.on("change", listener);
+    this._ctx.onDispose(() => {
+      handle.off("change", listener);
+    });
+  }
+  _onUpdate(event) {
+    if (this._metadata == null) {
+      return;
+    }
+    const objectIds = getInlineChanges(event);
+    if (objectIds.length === 0) {
+      return;
+    }
+    const heads = (0, import_automerge.getHeads)(event.doc);
+    const lastAvailableHash = heads.at(-1);
+    if (!lastAvailableHash) {
+      return;
+    }
+    const encodedIds = objectIds.map((objectId) => import_protocols.idCodec.encode({
+      documentId: event.handle.documentId,
+      objectId
+    }));
+    const idToLastHash = new Map(encodedIds.map((id) => [
+      id,
+      lastAvailableHash
+    ]));
+    const markingDirtyPromise = this._metadata.markDirty(idToLastHash).then(() => {
+      this._updatingMetadata.delete(event.handle.documentId);
+    }).catch((err) => {
+      this._ctx.disposed && import_log.log.catch(err, void 0, {
+        F: __dxlog_file3,
+        L: 188,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+    this._updatingMetadata.set(event.handle.documentId, markingDirtyPromise);
+  }
+  _automergeDocs() {
+    return (0, import_util.mapValues)(this._repo.handles, (handle) => ({
+      state: handle.state,
+      hasDoc: !!handle.docSync(),
+      heads: handle.docSync() ? import_automerge.next.getHeads(handle.docSync()) : null,
+      data: handle.docSync()?.doc && (0, import_util.mapValues)(handle.docSync()?.doc, (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 close() {
+    await this._storage.close();
+    await this._clientNetwork.close();
+    await this._ctx.dispose();
+  }
+  //
+  // Methods for client-services.
+  //
+  syncRepo(request) {
+    return this._clientNetwork.syncRepo(request);
+  }
+  sendSyncMessage(request) {
+    return this._clientNetwork.sendSyncMessage(request);
+  }
+  async getHostInfo() {
+    return this._clientNetwork.getHostInfo();
+  }
+  //
+  // Mesh replication.
+  //
+  createExtension() {
+    return this._meshNetwork.createExtension();
+  }
+  authorizeDevice(spaceKey, deviceKey) {
+    (0, import_log.log)("authorizeDevice", {
+      spaceKey,
+      deviceKey
+    }, {
+      F: __dxlog_file3,
+      L: 255,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    (0, import_util.defaultMap)(this._authorizedDevices, spaceKey, () => new import_util.ComplexSet(import_keys.PublicKey.hash)).add(deviceKey);
+  }
+};
+_ts_decorate([
+  import_tracing.trace.info()
+], AutomergeHost.prototype, "_peerId", void 0);
+_ts_decorate([
+  import_tracing.trace.info({
+    depth: null
+  })
+], AutomergeHost.prototype, "_automergeDocs", null);
+_ts_decorate([
+  import_tracing.trace.info({
+    depth: null
+  })
+], AutomergeHost.prototype, "_automergePeers", null);
+AutomergeHost = _ts_decorate([
+  import_tracing.trace.resource()
+], AutomergeHost);
+var getInlineChanges = (event) => {
+  const inlineChangedObjectIds = /* @__PURE__ */ new Set();
+  for (const { path } of event.patches) {
+    if (path.length < 2) {
+      continue;
+    }
+    switch (path[0]) {
+      case "objects":
+        if (path.length >= 2) {
+          inlineChangedObjectIds.add(path[1]);
+        }
+        break;
+    }
+  }
+  return [
+    ...inlineChangedObjectIds
+  ];
+};
+var getSpaceKeyFromDoc = (doc) => {
+  const rawSpaceKey = doc.access?.spaceKey ?? doc.experimental_spaceKey;
+  if (rawSpaceKey == null) {
+    return null;
+  }
+  return String(rawSpaceKey);
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthExtension,