@dxos/echo-pipeline 0.4.9 → 0.4.10-main.05b9ab6

package/dist/lib/browser/index.mjs

@@ -2,6 +2,7 @@ import "@dxos/node-std/globals";
 import {
   AuthExtension,
   AuthStatus,
+  Buffer,
   DataServiceImpl,
   MOCK_AUTH_PROVIDER,
   MOCK_AUTH_VERIFIER,
@@ -16,142 +17,130 @@ import {
   TimeframeClock,
   codec,
   createMappedFeedWriter,
+  hasInvitationExpired,
   mapFeedIndexesToTimeframe,
   mapTimeframeToFeedIndexes,
   startAfter,
   valueEncoding
-} from "./chunk-RTEEJ723.mjs";
+} from "./chunk-KMWJLYEQ.mjs";
 
 // packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts
-import { next as automerge, getHeads } from "@dxos/automerge/automerge";
+import { asyncTimeout } from "@dxos/async";
+import { next as automerge } from "@dxos/automerge/automerge";
 import { Repo } from "@dxos/automerge/automerge-repo";
-import { IndexedDBStorageAdapter } from "@dxos/automerge/automerge-repo-storage-indexeddb";
 import { Context } from "@dxos/context";
 import { PublicKey } from "@dxos/keys";
 import { log as log3 } from "@dxos/log";
-import { idCodec } from "@dxos/protocols";
-import { StorageType } from "@dxos/random-access-storage";
 import { trace } from "@dxos/tracing";
 import { ComplexMap, ComplexSet, defaultMap, mapValues } from "@dxos/util";
 
-// packages/core/echo/echo-pipeline/src/automerge/automerge-storage-adapter.ts
-import { arrayToBuffer, bufferToArray } from "@dxos/util";
-var AutomergeStorageAdapter = class {
-  constructor(_directory) {
-    this._directory = _directory;
-    this._state = "opened";
+// packages/core/echo/echo-pipeline/src/automerge/leveldb-storage-adapter.ts
+import { LifecycleState, Resource } from "@dxos/context";
+var LevelDBStorageAdapter = class extends Resource {
+  constructor(_params) {
+    super();
+    this._params = _params;
   }
-  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;
+  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;
     }
-    const buffer = await file.read(0, size);
-    return bufferToArray(buffer);
   }
-  async save(key, data) {
-    if (this._state !== "opened") {
+  async save(keyArray, binary) {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
       return void 0;
     }
-    const filename = this._getFilename(key);
-    const file = this._directory.getOrCreateFile(filename);
-    await file.write(0, arrayToBuffer(data));
-    await file.truncate?.(data.length);
-    await file.flush?.();
+    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(key) {
-    if (this._state !== "opened") {
+  async remove(keyArray) {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
       return void 0;
     }
-    const filename = this._getFilename(key);
-    const file = this._directory.getOrCreateFile(filename);
-    await file.destroy();
+    await this._params.db.del(keyArray, {
+      ...encodingOptions
+    });
   }
   async loadRange(keyPrefix) {
-    if (this._state !== "opened") {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
       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: bufferToArray(buffer)
-      };
-    }));
+    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._state !== "opened") {
+    if (this._lifecycleState !== LifecycleState.OPEN) {
       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", "%"));
-  }
-};
-
-// packages/core/echo/echo-pipeline/src/automerge/automerge-storage–wrapper.ts
-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();
+    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", "%"))
+};
+var encodingOptions = {
+  keyEncoding: keyEncoder,
+  valueEncoding: "buffer"
+};
+var isLevelDbNotFoundError = (err) => err.code === "LEVEL_NOT_FOUND";
 
 // packages/core/echo/echo-pipeline/src/automerge/local-host-network-adapter.ts
 import { Trigger } from "@dxos/async";
 import { NetworkAdapter, cbor } from "@dxos/automerge/automerge-repo";
 import { Stream } from "@dxos/codec-protobuf";
 import { invariant } from "@dxos/invariant";
-import { log } from "@dxos/log";
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/local-host-network-adapter.ts";
 var LocalHostNetworkAdapter = class extends NetworkAdapter {
   constructor() {
     super(...arguments);
     this._peers = /* @__PURE__ */ new Map();
     this._connected = new Trigger();
+    this._isConnected = false;
   }
   /**
   * Emits `ready` event. That signals to `Repo` that it can start using the adapter.
@@ -161,15 +150,21 @@ var LocalHostNetworkAdapter = class extends NetworkAdapter {
       network: this
     });
   }
+  /**
+  * Called by `Repo` to connect to the network.
+  *
+  * @param peerId Our peer Id.
+  */
   connect(peerId) {
     this.peerId = peerId;
+    this._isConnected = true;
     this._connected.wake();
   }
   send(message) {
     const peer = this._peers.get(message.targetId);
     invariant(peer, "Peer not found.", {
       F: __dxlog_file,
-      L: 45,
+      L: 51,
       S: this,
       A: [
         "peer",
@@ -184,12 +179,17 @@ var LocalHostNetworkAdapter = class extends NetworkAdapter {
   }
   disconnect() {
   }
+  async whenConnected() {
+    await this._connected.wait({
+      timeout: 1e4
+    });
+  }
   syncRepo({ id, syncMessage }) {
     const peerId = this._getPeerId(id);
     return new Stream(({ next, close }) => {
       invariant(!this._peers.has(peerId), "Peer already connected.", {
         F: __dxlog_file,
-        L: 63,
+        L: 73,
         S: this,
         A: [
           "!this._peers.has(peerId)",
@@ -211,35 +211,47 @@ var LocalHostNetworkAdapter = class extends NetworkAdapter {
           });
         }
       });
-      this._connected.wait({
-        timeout: 1e3
-      }).then(() => {
-        this.emit("peer-candidate", {
-          peerMetadata: {},
-          peerId
-        });
-      }).catch((err) => log.catch(err, void 0, {
+      invariant(this._isConnected, void 0, {
         F: __dxlog_file,
-        L: 88,
+        L: 90,
         S: this,
-        C: (f, a) => f(...a)
-      }));
+        A: [
+          "this._isConnected",
+          ""
+        ]
+      });
+      this.emit("peer-candidate", {
+        peerMetadata: {},
+        peerId
+      });
     });
   }
   async sendSyncMessage({ id, syncMessage }) {
-    await this._connected.wait({
-      timeout: 1e3
+    invariant(this._isConnected, void 0, {
+      F: __dxlog_file,
+      L: 99,
+      S: this,
+      A: [
+        "this._isConnected",
+        ""
+      ]
     });
     const message = cbor.decode(syncMessage);
     this.emit("message", message);
   }
   async getHostInfo() {
-    await this._connected.wait({
-      timeout: 1e3
+    invariant(this._isConnected, void 0, {
+      F: __dxlog_file,
+      L: 105,
+      S: this,
+      A: [
+        "this._isConnected",
+        ""
+      ]
     });
     invariant(this.peerId, "Peer id not set.", {
       F: __dxlog_file,
-      L: 100,
+      L: 106,
       S: this,
       A: [
         "this.peerId",
@@ -259,7 +271,7 @@ var LocalHostNetworkAdapter = class extends NetworkAdapter {
 import { Trigger as Trigger2 } from "@dxos/async";
 import { NetworkAdapter as NetworkAdapter2, cbor as cbor2 } from "@dxos/automerge/automerge-repo";
 import { invariant as invariant2 } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
+import { log } from "@dxos/log";
 import { AutomergeReplicator } from "@dxos/teleport-extension-automerge-replicator";
 var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/mesh-network-adapter.ts";
 var MeshNetworkAdapter = class extends NetworkAdapter2 {
@@ -294,7 +306,7 @@ var MeshNetworkAdapter = class extends NetworkAdapter2 {
     });
     extension.sendSyncMessage({
       payload: cbor2.encode(message)
-    }).catch((err) => log2.catch(err, void 0, {
+    }).catch((err) => log.catch(err, void 0, {
       F: __dxlog_file2,
       L: 39,
       S: this,
@@ -319,7 +331,7 @@ var MeshNetworkAdapter = class extends NetworkAdapter2 {
     }, {
       onStartReplication: async (info, remotePeerId) => {
         await this._connected.wait();
-        log2("onStartReplication", {
+        log("onStartReplication", {
           id: info.id,
           thisPeerId: this.peerId,
           remotePeerId: remotePeerId.toHex()
@@ -332,7 +344,7 @@ var MeshNetworkAdapter = class extends NetworkAdapter2 {
         if (!this._extensions.has(info.id)) {
           peerInfo = info;
           this._extensions.set(info.id, extension);
-          log2("peer-candidate", {
+          log("peer-candidate", {
             id: info.id,
             thisPeerId: this.peerId,
             remotePeerId: remotePeerId.toHex()
@@ -372,6 +384,118 @@ var MeshNetworkAdapter = class extends NetworkAdapter2 {
   }
 };
 
+// packages/core/echo/echo-pipeline/src/automerge/migrations.ts
+import { IndexedDBStorageAdapter } from "@dxos/automerge/automerge-repo-storage-indexeddb";
+import { log as log2 } from "@dxos/log";
+import { StorageType } from "@dxos/random-access-storage";
+
+// packages/core/echo/echo-pipeline/src/automerge/automerge-storage-adapter.ts
+import { arrayToBuffer, bufferToArray } from "@dxos/util";
+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 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, 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: 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", "%"));
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/automerge/migrations.ts
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/migrations.ts";
+var levelMigration = async ({ db, directory }) => {
+  const isNewLevel = !await db.iterator({
+    ...encodingOptions
+  }).next();
+  if (!isNewLevel) {
+    return;
+  }
+  const oldStorageAdapter = directory.type === StorageType.IDB ? new IndexedDBStorageAdapter(directory.path, "data") : new AutomergeStorageAdapter(directory);
+  const chunks = await oldStorageAdapter.loadRange([]);
+  if (chunks.length === 0) {
+    return;
+  }
+  const batch = db.batch();
+  log2.info("found chunks on old storage adapter", {
+    chunks: chunks.length
+  }, {
+    F: __dxlog_file3,
+    L: 36,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  for (const { key, data } of await oldStorageAdapter.loadRange([])) {
+    data && batch.put(key, data, {
+      ...encodingOptions
+    });
+  }
+  await batch.write();
+};
+
 // packages/core/echo/echo-pipeline/src/automerge/automerge-host.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;
@@ -383,29 +507,32 @@ 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_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-host.ts";
 var AutomergeHost = class {
-  constructor({ directory, metadata }) {
+  constructor({ directory, db, storageCallbacks }) {
     this._ctx = new Context();
     /**
     * spaceKey -> deviceKey[]
     */
     this._authorizedDevices = new ComplexMap(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 === StorageType.IDB ? new IndexedDBStorageAdapter(directory.path, "data") : new AutomergeStorageAdapter(directory)
-      ),
-      callbacks: {
-        beforeSave: (params) => this._beforeSave(params)
-      }
+    this._directory = directory;
+    this._db = db;
+    this._storageCallbacks = storageCallbacks;
+  }
+  async open() {
+    this._directory && await levelMigration({
+      db: this._db,
+      directory: this._directory
+    });
+    this._storage = new LevelDBStorageAdapter({
+      db: this._db,
+      callbacks: this._storageCallbacks
     });
+    await this._storage.open?.();
     this._peerId = `host-${PublicKey.random().toHex()}`;
+    this._meshNetwork = new MeshNetworkAdapter();
+    this._clientNetwork = new LocalHostNetworkAdapter();
     this._repo = new Repo({
       peerId: this._peerId,
       network: [
@@ -430,8 +557,8 @@ var AutomergeHost = class {
             documentId,
             isRequested
           }, {
-            F: __dxlog_file3,
-            L: 96,
+            F: __dxlog_file4,
+            L: 100,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -444,8 +571,8 @@ var AutomergeHost = class {
               peerId,
               documentId
             }, {
-              F: __dxlog_file3,
-              L: 103,
+              F: __dxlog_file4,
+              L: 107,
               S: this,
               C: (f, a) => f(...a)
             });
@@ -458,8 +585,8 @@ var AutomergeHost = class {
               peerId,
               documentId
             }, {
-              F: __dxlog_file3,
-              L: 112,
+              F: __dxlog_file4,
+              L: 116,
               S: this,
               C: (f, a) => f(...a)
             });
@@ -475,16 +602,16 @@ var AutomergeHost = class {
             spaceKey,
             isAuthorized
           }, {
-            F: __dxlog_file3,
-            L: 118,
+            F: __dxlog_file4,
+            L: 122,
             S: this,
             C: (f, a) => f(...a)
           });
           return isAuthorized;
         } catch (err) {
           log3.catch(err, void 0, {
-            F: __dxlog_file3,
-            L: 128,
+            F: __dxlog_file4,
+            L: 132,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -494,69 +621,22 @@ var AutomergeHost = class {
     });
     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);
-      });
-    }
+    await this._clientNetwork.whenConnected();
+  }
+  async close() {
+    await this._storage.close?.();
+    await this._clientNetwork.close();
+    await this._ctx.dispose();
   }
   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 = getHeads(event.doc);
-    const lastAvailableHash = heads.join("");
-    if (!lastAvailableHash) {
-      return;
-    }
-    const encodedIds = objectIds.map((objectId) => 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 && log3.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 mapValues(this._repo.handles, (handle) => ({
       state: handle.state,
       hasDoc: !!handle.docSync(),
       heads: handle.docSync() ? automerge.getHeads(handle.docSync()) : null,
-      data: handle.docSync()?.doc && mapValues(handle.docSync()?.doc, (value, key) => {
+      data: handle.docSync() && mapValues(handle.docSync(), (value, key) => {
         try {
           switch (key) {
             case "access":
@@ -576,14 +656,25 @@ var AutomergeHost = class {
   _automergePeers() {
     return this._repo.peers;
   }
-  async close() {
-    await this._storage.close();
-    await this._clientNetwork.close();
-    await this._ctx.dispose();
-  }
   //
   // Methods for client-services.
   //
+  async flush({ documentIds }) {
+    await Promise.all(documentIds?.map((id) => this._repo.find(id).whenReady()) ?? []);
+    try {
+      await asyncTimeout(this._repo.flush(documentIds), 500);
+    } catch (err) {
+      log3.warn("flush error", {
+        documentIds,
+        err
+      }, {
+        F: __dxlog_file4,
+        L: 196,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
   syncRepo(request) {
     return this._clientNetwork.syncRepo(request);
   }
@@ -604,8 +695,8 @@ var AutomergeHost = class {
       spaceKey,
       deviceKey
     }, {
-      F: __dxlog_file3,
-      L: 255,
+      F: __dxlog_file4,
+      L: 221,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -625,27 +716,14 @@ _ts_decorate([
     depth: null
   })
 ], AutomergeHost.prototype, "_automergePeers", null);
+_ts_decorate([
+  trace.span({
+    showInBrowserTimeline: true
+  })
+], AutomergeHost.prototype, "flush", null);
 AutomergeHost = _ts_decorate([
   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) {
@@ -653,18 +731,335 @@ var getSpaceKeyFromDoc = (doc) => {
   }
   return String(rawSpaceKey);
 };
+
+// packages/core/echo/echo-pipeline/src/automerge/automerge-doc-loader.ts
+import { Event } from "@dxos/async";
+import { cancelWithContext } from "@dxos/context";
+import { warnAfterTimeout } from "@dxos/debug";
+import { invariant as invariant3 } from "@dxos/invariant";
+import { log as log4 } from "@dxos/log";
+import { trace as trace2 } from "@dxos/tracing";
+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_file5 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/automerge-doc-loader.ts";
+var AutomergeDocumentLoaderImpl = class {
+  constructor(_spaceKey, _repo) {
+    this._spaceKey = _spaceKey;
+    this._repo = _repo;
+    this._spaceRootDocHandle = null;
+    this._objectDocumentHandles = /* @__PURE__ */ new Map();
+    this._objectsPendingDocumentLoad = /* @__PURE__ */ new Set();
+    this.onObjectDocumentLoaded = new Event();
+  }
+  getAllHandles() {
+    return [
+      ...new Set(this._objectDocumentHandles.values())
+    ];
+  }
+  async loadSpaceRootDocHandle(ctx, spaceState) {
+    if (this._spaceRootDocHandle != null) {
+      return;
+    }
+    if (!spaceState.rootUrl) {
+      log4.error("Database opened with no rootUrl", {
+        spaceKey: this._spaceKey
+      }, {
+        F: __dxlog_file5,
+        L: 69,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._createContextBoundSpaceRootDocument(ctx);
+    } else {
+      const existingDocHandle = await this._initDocHandle(ctx, spaceState.rootUrl);
+      const doc = existingDocHandle.docSync();
+      invariant3(doc, void 0, {
+        F: __dxlog_file5,
+        L: 74,
+        S: this,
+        A: [
+          "doc",
+          ""
+        ]
+      });
+      if (doc.access == null) {
+        this._initDocAccess(existingDocHandle);
+      }
+      this._spaceRootDocHandle = existingDocHandle;
+    }
+  }
+  loadObjectDocument(objectId) {
+    invariant3(this._spaceRootDocHandle, void 0, {
+      F: __dxlog_file5,
+      L: 83,
+      S: this,
+      A: [
+        "this._spaceRootDocHandle",
+        ""
+      ]
+    });
+    if (this._objectDocumentHandles.has(objectId) || this._objectsPendingDocumentLoad.has(objectId)) {
+      return;
+    }
+    const spaceRootDoc = this._spaceRootDocHandle.docSync();
+    invariant3(spaceRootDoc, void 0, {
+      F: __dxlog_file5,
+      L: 88,
+      S: this,
+      A: [
+        "spaceRootDoc",
+        ""
+      ]
+    });
+    const documentUrl = (spaceRootDoc.links ?? {})[objectId];
+    if (documentUrl == null) {
+      this._objectsPendingDocumentLoad.add(objectId);
+      log4.info("loading delayed until object links are initialized", {
+        objectId
+      }, {
+        F: __dxlog_file5,
+        L: 92,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    this._loadLinkedObjects({
+      [objectId]: documentUrl
+    });
+  }
+  onObjectLinksUpdated(links) {
+    if (!links) {
+      return;
+    }
+    const linksAwaitingLoad = Object.entries(links).filter(([objectId]) => this._objectsPendingDocumentLoad.has(objectId));
+    this._loadLinkedObjects(Object.fromEntries(linksAwaitingLoad));
+    linksAwaitingLoad.forEach(([objectId]) => this._objectsPendingDocumentLoad.delete(objectId));
+  }
+  getSpaceRootDocHandle() {
+    invariant3(this._spaceRootDocHandle, void 0, {
+      F: __dxlog_file5,
+      L: 110,
+      S: this,
+      A: [
+        "this._spaceRootDocHandle",
+        ""
+      ]
+    });
+    return this._spaceRootDocHandle;
+  }
+  createDocumentForObject(objectId) {
+    invariant3(this._spaceRootDocHandle, void 0, {
+      F: __dxlog_file5,
+      L: 115,
+      S: this,
+      A: [
+        "this._spaceRootDocHandle",
+        ""
+      ]
+    });
+    const spaceDocHandle = this._repo.create();
+    this._initDocAccess(spaceDocHandle);
+    this.onObjectBoundToDocument(spaceDocHandle, objectId);
+    this._spaceRootDocHandle.change((newDoc) => {
+      newDoc.links ??= {};
+      newDoc.links[objectId] = spaceDocHandle.url;
+    });
+    return spaceDocHandle;
+  }
+  onObjectBoundToDocument(handle, objectId) {
+    this._objectDocumentHandles.set(objectId, handle);
+  }
+  clearHandleReferences() {
+    const objectsWithHandles = [
+      ...this._objectDocumentHandles.keys()
+    ];
+    this._objectDocumentHandles.clear();
+    this._spaceRootDocHandle = null;
+    return objectsWithHandles;
+  }
+  _loadLinkedObjects(links) {
+    if (!links) {
+      return;
+    }
+    for (const [objectId, automergeUrl] of Object.entries(links)) {
+      const logMeta = {
+        objectId,
+        automergeUrl
+      };
+      const objectDocumentHandle = this._objectDocumentHandles.get(objectId);
+      if (objectDocumentHandle != null && objectDocumentHandle.url !== automergeUrl) {
+        log4.warn("object already inlined in a different document, ignoring the link", {
+          ...logMeta,
+          actualDocumentUrl: objectDocumentHandle.url
+        }, {
+          F: __dxlog_file5,
+          L: 145,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      if (objectDocumentHandle?.url === automergeUrl) {
+        log4.warn("object document was already loaded", logMeta, {
+          F: __dxlog_file5,
+          L: 152,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const handle = this._repo.find(automergeUrl);
+      log4.debug("document loading triggered", logMeta, {
+        F: __dxlog_file5,
+        L: 156,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._objectDocumentHandles.set(objectId, handle);
+      void this._createObjectOnDocumentLoad(handle, objectId);
+    }
+  }
+  async _initDocHandle(ctx, url) {
+    const docHandle = this._repo.find(url);
+    while (true) {
+      try {
+        await warnAfterTimeout(5e3, "Automerge root doc load timeout (AutomergeDb)", async () => {
+          await cancelWithContext(ctx, docHandle.whenReady());
+        });
+        break;
+      } catch (err) {
+        if (`${err}`.includes("Timeout")) {
+          log4.info("wraparound", {
+            id: docHandle.documentId,
+            state: docHandle.state
+          }, {
+            F: __dxlog_file5,
+            L: 172,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          continue;
+        }
+        throw err;
+      }
+    }
+    if (docHandle.state === "unavailable") {
+      throw new Error("Automerge document is unavailable");
+    }
+    return docHandle;
+  }
+  _createContextBoundSpaceRootDocument(ctx) {
+    const docHandle = this._repo.create();
+    this._spaceRootDocHandle = docHandle;
+    ctx.onDispose(() => {
+      docHandle.delete();
+      this._spaceRootDocHandle = null;
+    });
+  }
+  _initDocAccess(handle) {
+    handle.change((newDoc) => {
+      newDoc.access ??= {
+        spaceKey: this._spaceKey.toHex()
+      };
+      newDoc.access.spaceKey = this._spaceKey.toHex();
+    });
+  }
+  async _createObjectOnDocumentLoad(handle, objectId) {
+    try {
+      await handle.doc([
+        "ready"
+      ]);
+      const logMeta = {
+        objectId,
+        docUrl: handle.url
+      };
+      if (this.onObjectDocumentLoaded.listenerCount() === 0) {
+        log4.info("document loaded after all listeners were removed", logMeta, {
+          F: __dxlog_file5,
+          L: 208,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      const objectDocHandle = this._objectDocumentHandles.get(objectId);
+      if (objectDocHandle?.url !== handle.url) {
+        log4.warn("object was rebound while a document was loading, discarding handle", logMeta, {
+          F: __dxlog_file5,
+          L: 213,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return;
+      }
+      this.onObjectDocumentLoaded.emit({
+        handle,
+        objectId
+      });
+    } catch (err) {
+      const shouldRetryLoading = this.onObjectDocumentLoaded.listenerCount() > 0;
+      log4.warn("failed to load a document", {
+        objectId,
+        automergeUrl: handle.url,
+        retryLoading: shouldRetryLoading,
+        err
+      }, {
+        F: __dxlog_file5,
+        L: 219,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      if (shouldRetryLoading) {
+        await this._createObjectOnDocumentLoad(handle, objectId);
+      }
+    }
+  }
+};
+_ts_decorate2([
+  trace2.span({
+    showInBrowserTimeline: true
+  })
+], AutomergeDocumentLoaderImpl.prototype, "loadSpaceRootDocHandle", null);
+AutomergeDocumentLoaderImpl = _ts_decorate2([
+  trace2.resource()
+], AutomergeDocumentLoaderImpl);
+
+// packages/core/echo/echo-pipeline/src/automerge/reference.ts
+import { Reference } from "@dxos/echo-schema";
+var REFERENCE_TYPE_TAG = "dxos.echo.model.document.Reference";
+var encodeReference = (reference) => ({
+  "@type": REFERENCE_TYPE_TAG,
+  // NOTE: Automerge do not support undefined values, so we need to use null instead.
+  itemId: reference.itemId ?? null,
+  protocol: reference.protocol ?? null,
+  host: reference.host ?? null
+});
+var decodeReference = (value) => new Reference(value.itemId, value.protocol ?? void 0, value.host ?? void 0);
+var isEncodedReferenceObject = (value) => typeof value === "object" && value !== null && value["@type"] === REFERENCE_TYPE_TAG;
 export {
   AuthExtension,
   AuthStatus,
+  AutomergeDocumentLoaderImpl,
   AutomergeHost,
   AutomergeStorageAdapter,
   DataServiceImpl,
+  LevelDBStorageAdapter,
   LocalHostNetworkAdapter,
   MOCK_AUTH_PROVIDER,
   MOCK_AUTH_VERIFIER,
   MeshNetworkAdapter,
   MetadataStore,
   Pipeline,
+  REFERENCE_TYPE_TAG,
   SnapshotManager,
   SnapshotStore,
   Space,
@@ -674,7 +1069,12 @@ export {
   TimeframeClock,
   codec,
   createMappedFeedWriter,
+  decodeReference,
+  encodeReference,
+  encodingOptions,
   getSpaceKeyFromDoc,
+  hasInvitationExpired,
+  isEncodedReferenceObject,
   mapFeedIndexesToTimeframe,
   mapTimeframeToFeedIndexes,
   startAfter,