@dxos/echo-pipeline 0.1.41 → 0.1.45-next.45667d4

package/dist/lib/browser/{chunk-4YAT2XJW.mjs → chunk-2NGLSBL4.mjs}

@@ -116,13 +116,18 @@ var MetadataStore = class {
       await file.close();
     }
   }
+  _getSpace(spaceKey) {
+    const space = this.spaces.find((space2) => space2.key === spaceKey);
+    assert(space, "Space not found");
+    return space;
+  }
   /**
   * Clears storage - doesn't work for now.
   */
   async clear() {
     log("clearing all metadata", {}, {
       file: "metadata-store.ts",
-      line: 126,
+      line: 132,
       scope: this,
       callSite: (f, a) => f(...a)
     });
@@ -143,20 +148,15 @@ var MetadataStore = class {
     await this._save();
   }
   async setSpaceLatestTimeframe(spaceKey, timeframe) {
-    const space = this.spaces.find((space2) => space2.key === spaceKey);
-    assert(space, "Space not found");
-    space.dataTimeframe = timeframe;
+    this._getSpace(spaceKey).dataTimeframe = timeframe;
     await this._save();
   }
-  async setSpaceSnapshot(spaceKey, snapshot) {
-    const space = this.spaces.find((space2) => space2.key === spaceKey);
-    assert(space, "Space not found");
-    space.snapshot = snapshot;
+  async setCache(spaceKey, cache) {
+    this._getSpace(spaceKey).cache = cache;
     await this._save();
   }
   async setWritableFeedKeys(spaceKey, controlFeedKey, dataFeedKey) {
-    const space = this.spaces.find((space2) => space2.key === spaceKey);
-    assert(space, "Space not found");
+    const space = this._getSpace(spaceKey);
     space.controlFeedKey = controlFeedKey;
     space.dataFeedKey = dataFeedKey;
     await this._save();
@@ -233,6 +233,11 @@ var TimeframeClock = class {
   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([
       [
@@ -250,12 +255,12 @@ var TimeframeClock = class {
     return !gaps.isEmpty();
   }
   async waitUntilReached(target) {
-    log2.info("waitUntilReached", {
+    log2("waitUntilReached", {
       target,
       current: this._timeframe
     }, {
       file: "timeframe-clock.ts",
-      line: 67,
+      line: 73,
       scope: this,
       callSite: (f, a) => f(...a)
     });
@@ -266,7 +271,7 @@ var TimeframeClock = class {
         deps: Timeframe.dependencies(target, this._timeframe)
       }, {
         file: "timeframe-clock.ts",
-        line: 69,
+        line: 75,
         scope: this,
         callSite: (f, a) => f(...a)
       });
@@ -280,12 +285,14 @@ __decorate2([
 
 // packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
 import assert4 from "@dxos/node-std/assert";
-import { sleep, synchronized as synchronized2, Trigger } from "@dxos/async";
+import { Event as Event2, sleep, synchronized as synchronized2, Trigger } from "@dxos/async";
 import { Context, rejectOnDispose } from "@dxos/context";
+import { failUndefined } from "@dxos/debug";
 import { FeedSetIterator } from "@dxos/feed-store";
 import { PublicKey } from "@dxos/keys";
 import { log as log4 } 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 debug from "debug";
@@ -317,10 +324,11 @@ var __decorate3 = function(decorators, target, key, desc) {
 };
 var PipelineState = class {
   // prettier-ignore
-  constructor(_iterator, _timeframeClock) {
-    this._iterator = _iterator;
+  constructor(_feeds, _timeframeClock) {
+    this._feeds = _feeds;
     this._timeframeClock = _timeframeClock;
     this.timeframeUpdate = this._timeframeClock.update;
+    this.stalled = new Event2();
   }
   /**
   * Latest theoretical timeframe based on the last mutation in each feed.
@@ -328,7 +336,7 @@ var PipelineState = class {
   */
   // TODO(dmaretskyi): Rename `totalTimeframe`? or `lastTimeframe`.
   get endTimeframe() {
-    return mapFeedIndexesToTimeframe(this._iterator.feeds.filter((feed) => feed.length > 0).map((feed) => ({
+    return mapFeedIndexesToTimeframe(Array.from(this._feeds.values()).filter((feed) => feed.length > 0).map((feed) => ({
       feedKey: feed.key,
       index: feed.length - 1
     })));
@@ -343,7 +351,7 @@ var PipelineState = class {
     return this._targetTimeframe ? this._targetTimeframe : new Timeframe2();
   }
   get feeds() {
-    return this._iterator.feeds;
+    return Array.from(this._feeds.values());
   }
   async waitUntilTimeframe(target) {
     await this._timeframeClock.waitUntilReached(target);
@@ -366,7 +374,7 @@ var PipelineState = class {
       target: this.targetTimeframe
     }, {
       file: "pipeline.ts",
-      line: 105,
+      line: 109,
       scope: this,
       callSite: (f, a) => f(...a)
     });
@@ -375,7 +383,7 @@ var PipelineState = class {
         return Timeframe2.dependencies(this.targetTimeframe, this.timeframe).isEmpty();
       }),
       ...breakOnStall ? [
-        this._iterator.stalled.discardParameter().waitForCount(1)
+        this.stalled.discardParameter().waitForCount(1)
       ] : []
     ]);
     let done = false;
@@ -396,7 +404,7 @@ var PipelineState = class {
             dependencies: Timeframe2.dependencies(this.targetTimeframe, this.timeframe)
           }, {
             file: "pipeline.ts",
-            line: 131,
+            line: 135,
             scope: this,
             callSite: (f, a) => f(...a)
           });
@@ -408,25 +416,18 @@ var PipelineState = class {
   }
 };
 var Pipeline = class {
-  // prettier-ignore
-  constructor(_initialTimeframe = new Timeframe2()) {
-    this._initialTimeframe = _initialTimeframe;
-    this._timeframeClock = new TimeframeClock(this._initialTimeframe);
-    this._feedSetIterator = new FeedSetIterator(createMessageSelector(this._timeframeClock), {
-      start: startAfter(this._initialTimeframe),
-      stallTimeout: 1e3
-    });
-    this._state = new PipelineState(this._feedSetIterator, this._timeframeClock);
+  constructor() {
+    this._timeframeClock = new TimeframeClock(new Timeframe2());
+    this._feeds = new ComplexMap(PublicKey.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._isStopping = false;
+    this._isStarted = false;
     this._isOpen = false;
-    this._feedSetIterator.stalled.on((iterator) => {
-      log4.warn(`Stalled after ${iterator.options.stallTimeout}ms with ${iterator.size} feeds.`, {}, {
-        file: "pipeline.ts",
-        line: 207,
-        scope: this,
-        callSite: (f, a) => f(...a)
-      });
-    });
+    this._isPaused = false;
   }
   get state() {
     return this._state;
@@ -441,10 +442,13 @@ var Pipeline = class {
   // NOTE: This cannot be synchronized with `stop` because stop waits for the mutation processing to complete,
   // which might be opening feeds during the mutation processing, which w
   async addFeed(feed) {
-    await this._feedSetIterator.addFeed(feed);
+    this._feeds.set(feed.key, feed);
+    if (this._feedSetIterator) {
+      await this._feedSetIterator.addFeed(feed);
+    }
   }
   hasFeed(feedKey) {
-    return this._feedSetIterator.hasFeed(feedKey);
+    return this._feeds.has(feedKey);
   }
   setWriteFeed(feed) {
     assert4(!this._writer, "Writer already set.");
@@ -457,33 +461,68 @@ var Pipeline = class {
   async start() {
     log4("starting...", {}, {
       file: "pipeline.ts",
-      line: 249,
+      line: 254,
       scope: this,
       callSite: (f, a) => f(...a)
     });
+    await this._initIterator();
     await this._feedSetIterator.open();
     log4("started", {}, {
       file: "pipeline.ts",
-      line: 251,
+      line: 257,
       scope: this,
       callSite: (f, a) => f(...a)
     });
+    this._isStarted = true;
   }
   async stop() {
+    var _a;
     log4("stopping...", {}, {
       file: "pipeline.ts",
-      line: 256,
+      line: 263,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-    await this._feedSetIterator.close();
+    this._isStopping = true;
+    await ((_a = this._feedSetIterator) == null ? void 0 : _a.close());
     await this._processingTrigger.wait();
     log4("stopped", {}, {
       file: "pipeline.ts",
-      line: 259,
+      line: 267,
       scope: this,
       callSite: (f, a) => f(...a)
     });
+    this._isStarted = false;
+  }
+  /**
+  * @param timeframe Timeframe of already processed messages. The pipeline will start processing messages AFTER this timeframe.
+  */
+  async setCursor(timeframe) {
+    assert4(!this._isStarted || this._isPaused, "Invalid state.");
+    this._timeframeClock.setTimeframe(timeframe);
+    if (this._feedSetIterator) {
+      await this._feedSetIterator.close();
+      await this._initIterator();
+      await this._feedSetIterator.open();
+    }
+  }
+  /**
+  * Calling pause while processing will cause a deadlock.
+  */
+  async pause() {
+    assert4(this._isStarted, "Pipeline is not open.");
+    if (this._isPaused) {
+      return;
+    }
+    this._pauseTrigger.reset();
+    await this._processingTrigger.wait();
+    this._isPaused = true;
+  }
+  async unpause() {
+    assert4(this._isStarted, "Pipeline is not open.");
+    assert4(this._isPaused, "Pipeline is not paused.");
+    this._pauseTrigger.wake();
+    this._isPaused = false;
   }
   /**
   * Starts to iterate over the ordered messages from the added feeds.
@@ -492,7 +531,21 @@ var Pipeline = class {
   async *consume() {
     assert4(!this._isOpen, "Pipeline is already being consumed.");
     this._isOpen = true;
-    for await (const block of this._feedSetIterator) {
+    assert4(this._feedSetIterator, "Iterator not initialized.");
+    let lastFeedSetIterator = this._feedSetIterator;
+    let iterable = lastFeedSetIterator[Symbol.asyncIterator]();
+    while (!this._isStopping) {
+      await this._pauseTrigger.wait();
+      if (lastFeedSetIterator !== this._feedSetIterator) {
+        assert4(this._feedSetIterator, "Iterator not initialized.");
+        lastFeedSetIterator = this._feedSetIterator;
+        iterable = lastFeedSetIterator[Symbol.asyncIterator]();
+      }
+      const { done, value } = await iterable.next();
+      if (done) {
+        continue;
+      }
+      const block = value != null ? value : failUndefined();
       this._processingTrigger.reset();
       this._timeframeClock.updatePendingTimeframe(PublicKey.from(block.feedKey), block.seq);
       yield block;
@@ -501,6 +554,24 @@ var Pipeline = class {
     }
     this._isOpen = false;
   }
+  async _initIterator() {
+    this._feedSetIterator = new FeedSetIterator(createMessageSelector(this._timeframeClock), {
+      start: startAfter(this._timeframeClock.timeframe),
+      stallTimeout: 1e3
+    });
+    this._feedSetIterator.stalled.on((iterator) => {
+      log4.warn(`Stalled after ${iterator.options.stallTimeout}ms with ${iterator.size} feeds.`, {}, {
+        file: "pipeline.ts",
+        line: 357,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this._state.stalled.emit();
+    });
+    for (const feed of this._feeds.values()) {
+      await this._feedSetIterator.addFeed(feed);
+    }
+  }
 };
 __decorate3([
   synchronized2
@@ -508,6 +579,15 @@ __decorate3([
 __decorate3([
   synchronized2
 ], Pipeline.prototype, "stop", null);
+__decorate3([
+  synchronized2
+], Pipeline.prototype, "setCursor", null);
+__decorate3([
+  synchronized2
+], Pipeline.prototype, "pause", null);
+__decorate3([
+  synchronized2
+], Pipeline.prototype, "unpause", null);
 
 // packages/core/echo/echo-pipeline/src/space/auth.ts
 import assert5 from "@dxos/node-std/assert";
@@ -527,7 +607,6 @@ var AuthExtension = class extends RpcExtension {
         AuthService: schema3.getService("dxos.mesh.teleport.auth.AuthService")
       },
       timeout: 60 * 1e3
-      // Long timeout because auth can wait for sync in certain cases.
     });
     this._authParams = _authParams;
     this._ctx = new Context2({
@@ -596,131 +675,150 @@ var AuthExtension = class extends RpcExtension {
   }
 };
 
-// packages/core/echo/echo-pipeline/src/space/space.ts
+// packages/core/echo/echo-pipeline/src/dbhost/data-service-host.ts
 import assert6 from "@dxos/node-std/assert";
-import { Event as Event2, synchronized as synchronized3, trackLeaks, Lock } from "@dxos/async";
-import { log as log7, logInfo } from "@dxos/log";
-import { AdmittedFeed as AdmittedFeed2 } from "@dxos/protocols/proto/dxos/halo/credentials";
-import { Callback as Callback2 } from "@dxos/util";
-
-// packages/core/echo/echo-pipeline/src/space/control-pipeline.ts
-import { SpaceStateMachine } from "@dxos/credentials";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { Stream } from "@dxos/codec-protobuf";
+import { tagMutationsInBatch, setMetadataOnObject } from "@dxos/echo-db";
 import { log as log6 } from "@dxos/log";
-import { AdmittedFeed } from "@dxos/protocols/proto/dxos/halo/credentials";
-import { Callback } from "@dxos/util";
-var ControlPipeline = class {
-  constructor({ spaceKey, genesisFeed, feedProvider, initialTimeframe }) {
-    this.onFeedAdmitted = new Callback();
-    this._pipeline = new Pipeline(initialTimeframe);
-    void this._pipeline.addFeed(genesisFeed);
-    this._spaceStateMachine = new SpaceStateMachine(spaceKey);
-    this._spaceStateMachine.onFeedAdmitted.set(async (info) => {
-      log6("feed admitted", {
-        key: info.key
-      }, {
-        file: "control-pipeline.ts",
-        line: 41,
-        scope: this,
-        callSite: (f, a) => f(...a)
+import { ComplexMap as ComplexMap2 } from "@dxos/util";
+var DataServiceHost = class {
+  constructor(_itemManager, _itemDemuxer, _writeStream) {
+    this._itemManager = _itemManager;
+    this._itemDemuxer = _itemDemuxer;
+    this._writeStream = _writeStream;
+    this._clientTagMap = new ComplexMap2(([feedKey, seq]) => `${feedKey.toHex()}:${seq}`);
+  }
+  /**
+  * Real-time subscription to data objects in a space.
+  */
+  subscribe() {
+    return new Stream(({ next, ctx }) => {
+      const objects = Array.from(this._itemManager.entities.values()).map((entity) => entity.createSnapshot());
+      next({
+        batch: {
+          objects
+        }
       });
-      if (info.assertion.designation === AdmittedFeed.Designation.CONTROL && !info.key.equals(genesisFeed.key)) {
-        try {
-          const feed = await feedProvider(info.key);
-          await this._pipeline.addFeed(feed);
-        } catch (err) {
-          log6.catch(err, {}, {
-            file: "control-pipeline.ts",
-            line: 49,
-            scope: this,
-            callSite: (f, a) => f(...a)
-          });
+      this._itemDemuxer.mutation.on(ctx, (message) => {
+        var _a;
+        const { batch, meta } = message;
+        log6("message", {
+          batch,
+          meta
+        }, {
+          file: "data-service-host.ts",
+          line: 49,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        const clientTag = this._clientTagMap.get([
+          message.meta.feedKey,
+          message.meta.seq
+        ]);
+        (_a = batch.objects) == null ? void 0 : _a.forEach((object) => {
+          setMetadataOnObject(object, meta);
+        });
+        if (clientTag) {
+          tagMutationsInBatch(batch, clientTag);
         }
-      }
-      await this.onFeedAdmitted.callIfSet(info);
+        next({
+          clientTag,
+          feedKey: message.meta.feedKey,
+          seq: message.meta.seq,
+          batch
+        });
+      });
     });
-    this.onMemberAdmitted = this._spaceStateMachine.onMemberAdmitted;
-    this.onCredentialProcessed = this._spaceStateMachine.onCredentialProcessed;
-  }
-  get spaceState() {
-    return this._spaceStateMachine;
-  }
-  get pipeline() {
-    return this._pipeline;
-  }
-  setWriteFeed(feed) {
-    this._pipeline.setWriteFeed(feed);
   }
-  async start() {
-    log6("starting...", {}, {
-      file: "control-pipeline.ts",
-      line: 73,
+  async write(request) {
+    var _a, _b, _c;
+    assert6(this._writeStream, "Cannot write mutations in readonly mode");
+    log6("write", {
+      clientTag: request.clientTag,
+      objectCount: (_b = (_a = request.batch.objects) == null ? void 0 : _a.length) != null ? _b : 0
+    }, {
+      file: "data-service-host.ts",
+      line: 77,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-    setTimeout(async () => {
-      for await (const msg of this._pipeline.consume()) {
-        try {
-          log6("processing", {
-            key: msg.feedKey,
-            seq: msg.seq
+    const message = {
+      batch: {
+        objects: (_c = request.batch.objects) == null ? void 0 : _c.map((object) => {
+          var _a2;
+          return {
+            ...object,
+            mutations: (_a2 = object.mutations) == null ? void 0 : _a2.map((mutation) => ({
+              ...mutation,
+              meta: void 0
+            })),
+            meta: void 0
+          };
+        })
+      }
+    };
+    const receipt = await this._writeStream.write(message, {
+      afterWrite: async (receipt2) => {
+        if (request.clientTag) {
+          log6("tag", {
+            clientTag: request.clientTag,
+            feedKey: receipt2.feedKey,
+            seq: receipt2.seq
           }, {
-            file: "control-pipeline.ts",
-            line: 78,
-            scope: this,
-            callSite: (f, a) => f(...a)
-          });
-          if (msg.data.payload.credential) {
-            const result = await this._spaceStateMachine.process(msg.data.payload.credential.credential, PublicKey2.from(msg.feedKey));
-            if (!result) {
-              log6.warn("processing failed", {
-                msg
-              }, {
-                file: "control-pipeline.ts",
-                line: 85,
-                scope: this,
-                callSite: (f, a) => f(...a)
-              });
-            }
-          }
-        } catch (err) {
-          log6.catch(err, {}, {
-            file: "control-pipeline.ts",
-            line: 89,
+            file: "data-service-host.ts",
+            line: 96,
             scope: this,
             callSite: (f, a) => f(...a)
           });
+          this._clientTagMap.set([
+            receipt2.feedKey,
+            receipt2.seq
+          ], request.clientTag);
         }
       }
     });
-    await this._pipeline.start();
-    log6("started", {}, {
-      file: "control-pipeline.ts",
-      line: 95,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
+    return receipt;
   }
-  async stop() {
-    log6("stopping...", {}, {
-      file: "control-pipeline.ts",
-      line: 99,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    await this._pipeline.stop();
-    log6("stopped", {}, {
-      file: "control-pipeline.ts",
-      line: 101,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
+};
+
+// packages/core/echo/echo-pipeline/src/dbhost/database-host.ts
+import { ItemDemuxer } from "@dxos/echo-db";
+var DatabaseHost = class {
+  constructor(_outboundStream) {
+    this._outboundStream = _outboundStream;
+  }
+  get isReadOnly() {
+    return !!this._outboundStream;
+  }
+  get echoProcessor() {
+    return this._echoProcessor;
+  }
+  async open(itemManager, modelFactory) {
+    this._itemManager = itemManager;
+    this._itemManager._debugLabel = "host";
+    this._itemDemuxer = new ItemDemuxer(itemManager, modelFactory);
+    this._echoProcessor = this._itemDemuxer.open();
+  }
+  async close() {
+  }
+  getWriteStream() {
+    return this._outboundStream;
+  }
+  createSnapshot() {
+    return this._itemDemuxer.createSnapshot();
+  }
+  createDataServiceHost() {
+    var _a;
+    return new DataServiceHost(this._itemManager, this._itemDemuxer, (_a = this._outboundStream) != null ? _a : void 0);
   }
 };
 
-// packages/core/echo/echo-pipeline/src/space/space.ts
-var __decorate4 = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+// packages/core/echo/echo-pipeline/src/dbhost/snapshot-manager.ts
+import { trackLeaks } from "@dxos/async";
+import { schema as schema4 } from "@dxos/protocols";
+import { ObjectSync } from "@dxos/teleport-extension-object-sync";
+var __decorate4 = function(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
@@ -729,183 +827,164 @@ var __decorate4 = function(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 Space = class Space2 {
-  constructor({ spaceKey, protocol, genesisFeed, feedProvider }) {
-    this._addFeedLock = new Lock();
-    this.onCredentialProcessed = new Callback2();
-    this.stateUpdate = new Event2();
-    this._isOpen = false;
-    assert6(spaceKey && feedProvider);
-    this._key = spaceKey;
-    this._genesisFeedKey = genesisFeed.key;
-    this._feedProvider = feedProvider;
-    this._controlPipeline = new ControlPipeline({
-      spaceKey,
-      genesisFeed,
-      feedProvider
-    });
-    this._controlPipeline.onFeedAdmitted.set(async (info) => {
-      if (info.assertion.designation === AdmittedFeed2.Designation.DATA) {
-        await this._addFeedLock.executeSynchronized(async () => {
-          if (this._dataPipeline) {
-            if (!this._dataPipeline.hasFeed(info.key)) {
-              return this._dataPipeline.addFeed(await this._feedProvider(info.key));
-            }
-          }
-        });
-      }
-      if (!info.key.equals(genesisFeed.key)) {
-        this.protocol.addFeed(await feedProvider(info.key));
+var SnapshotManager = class SnapshotManager2 {
+  // prettier-ignore
+  constructor(_snapshotStore) {
+    this._snapshotStore = _snapshotStore;
+    this._objectSync = new ObjectSync({
+      getObject: async (id) => {
+        const snapshot = await this._snapshotStore.loadSnapshot(id);
+        if (!snapshot) {
+          return void 0;
+        }
+        return {
+          id,
+          payload: schema4.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").encodeAsAny(snapshot)
+        };
+      },
+      setObject: async (data) => {
+        const snapshot = schema4.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(data.payload);
+        await this._snapshotStore.saveSnapshot(snapshot);
       }
     });
-    this._controlPipeline.onCredentialProcessed.set(async (credential) => {
-      await this.onCredentialProcessed.callIfSet(credential);
-      log7("onCredentialProcessed", {
-        credential
-      }, {
-        file: "space.ts",
-        line: 87,
-        scope: this,
-        callSite: (f, a) => f(...a)
-      });
-      this.stateUpdate.emit();
-    });
-    this.protocol = protocol;
-    this.protocol.addFeed(genesisFeed);
   }
-  get key() {
-    return this._key;
+  get objectSync() {
+    return this._objectSync;
   }
-  get isOpen() {
-    return this._isOpen;
+  async open() {
+    await this._objectSync.open();
   }
-  get genesisFeedKey() {
-    return this._genesisFeedKey;
+  async close() {
+    await this._objectSync.close();
   }
-  get controlFeedKey() {
-    var _a;
-    return (_a = this._controlFeed) == null ? void 0 : _a.key;
+  async load(id) {
+    const local = await this._snapshotStore.loadSnapshot(id);
+    if (local) {
+      return local;
+    }
+    const remote = await this._objectSync.download(id);
+    return schema4.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(remote.payload);
   }
-  get dataFeedKey() {
-    var _a;
-    return (_a = this._dataFeed) == null ? void 0 : _a.key;
+  async store(snapshot) {
+    const id = await this._snapshotStore.saveSnapshot(snapshot);
+    return id;
   }
-  get spaceState() {
-    return this._controlPipeline.spaceState;
+};
+SnapshotManager = __decorate4([
+  trackLeaks("open", "close")
+], SnapshotManager);
+
+// packages/core/echo/echo-pipeline/src/dbhost/snapshot-store.ts
+import { subtleCrypto } from "@dxos/crypto";
+import { schema as schema5 } from "@dxos/protocols";
+var SnapshotStore = class {
+  // prettier-ignore
+  constructor(_directory) {
+    this._directory = _directory;
   }
-  /**
-  * @test-only
-  */
-  get controlPipeline() {
-    return this._controlPipeline.pipeline;
+  async saveSnapshot(snapshot) {
+    const encoded = schema5.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").encode(snapshot);
+    const key = await subtleCrypto.digest("SHA-256", encoded);
+    const keyString = Buffer.from(key).toString("hex");
+    const file = await this._directory.getOrCreateFile(keyString);
+    try {
+      await file.write(0, Buffer.from(encoded));
+    } finally {
+      await file.close();
+    }
+    return keyString;
   }
-  setControlFeed(feed) {
-    assert6(!this._controlFeed, "Control feed already set.");
-    this._controlFeed = feed;
-    this._controlPipeline.setWriteFeed(feed);
-    return this;
+  async loadSnapshot(key) {
+    const file = await this._directory.getOrCreateFile(key);
+    try {
+      const { size } = await file.stat();
+      if (size === 0) {
+        return void 0;
+      }
+      const buffer = await file.read(0, size);
+      return schema5.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(buffer);
+    } finally {
+      await file.close();
+    }
   }
-  setDataFeed(feed) {
-    var _a;
-    assert6(!this._dataFeed, "Data feed already set.");
-    this._dataFeed = feed;
-    (_a = this._dataPipeline) == null ? void 0 : _a.setWriteFeed(feed);
-    return this;
+  async listSnapshots() {
+    const entries = await this._directory.list();
+    return await Promise.all(entries.map(async (key) => {
+      const { size } = await this._directory.getOrCreateFile(key).stat();
+      return {
+        key,
+        size
+      };
+    }));
   }
-  /**
-  * Use for diagnostics.
-  */
-  getControlFeeds() {
-    return Array.from(this._controlPipeline.spaceState.feeds.values());
+};
+
+// packages/core/echo/echo-pipeline/src/dbhost/data-service.ts
+import assert7 from "@dxos/node-std/assert";
+import { raise } from "@dxos/debug";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { log as log7 } from "@dxos/log";
+import { ComplexMap as ComplexMap3 } from "@dxos/util";
+var DataServiceSubscriptions = class {
+  constructor() {
+    this._spaces = new ComplexMap3(PublicKey2.hash);
   }
-  /**
-  * Use for diagnostics.
-  */
-  // getDataFeeds(): FeedInfo[] {
-  //   return this._dataPipeline?.getFeeds();
-  // }
-  async open() {
-    log7("opening...", {}, {
-      file: "space.ts",
-      line: 157,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    if (this._isOpen) {
-      return;
-    }
-    await this._controlPipeline.start();
-    await this.protocol.start();
-    this._isOpen = true;
-    log7("opened", {}, {
-      file: "space.ts",
-      line: 167,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
+  clear() {
+    this._spaces.clear();
   }
-  async close() {
-    log7("closing...", {
-      key: this._key
+  registerSpace(spaceKey, host) {
+    log7("Registering space", {
+      spaceKey
     }, {
-      file: "space.ts",
-      line: 172,
+      file: "data-service.ts",
+      line: 31,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-    if (!this._isOpen) {
-      return;
-    }
-    await this.protocol.stop();
-    await this._controlPipeline.stop();
-    this._isOpen = false;
-    log7("closed", {}, {
-      file: "space.ts",
-      line: 182,
+    this._spaces.set(spaceKey, host);
+  }
+  unregisterSpace(spaceKey) {
+    log7("Unregistering space", {
+      spaceKey
+    }, {
+      file: "data-service.ts",
+      line: 36,
       scope: this,
       callSite: (f, a) => f(...a)
     });
+    this._spaces.delete(spaceKey);
   }
-  // TODO(dmaretskyi): Make reusable.
-  async createDataPipeline({ start }) {
-    assert6(this._isOpen, "Space must be open to initialize data pipeline.");
-    assert6(!this._dataPipeline, "Data pipeline already initialized.");
-    const pipeline = new Pipeline(start);
-    if (this._dataFeed) {
-      pipeline.setWriteFeed(this._dataFeed);
-    }
-    this._dataPipeline = pipeline;
-    await this._addFeedLock.executeSynchronized(async () => {
-      for (const feed of this._controlPipeline.spaceState.feeds.values()) {
-        if (feed.assertion.designation === AdmittedFeed2.Designation.DATA && !pipeline.hasFeed(feed.key)) {
-          await pipeline.addFeed(await this._feedProvider(feed.key));
-        }
-      }
-    });
-    return pipeline;
+  getDataService(spaceKey) {
+    return this._spaces.get(spaceKey);
+  }
+};
+var DataServiceImpl = class {
+  constructor(_subscriptions) {
+    this._subscriptions = _subscriptions;
+  }
+  subscribe(request) {
+    var _a;
+    assert7(request.spaceKey);
+    const host = (_a = this._subscriptions.getDataService(request.spaceKey)) != null ? _a : raise(new Error(`space not found: ${request.spaceKey}`));
+    return host.subscribe();
+  }
+  write(request) {
+    var _a;
+    assert7(request.spaceKey);
+    assert7(request.batch);
+    const host = (_a = this._subscriptions.getDataService(request.spaceKey)) != null ? _a : raise(new Error(`space not found: ${request.spaceKey}`));
+    return host.write(request);
   }
 };
-__decorate4([
-  logInfo
-], Space.prototype, "key", null);
-__decorate4([
-  synchronized3
-], Space.prototype, "open", null);
-__decorate4([
-  synchronized3
-], Space.prototype, "close", null);
-Space = __decorate4([
-  trackLeaks("open", "close")
-], Space);
 
-// packages/core/echo/echo-pipeline/src/space/space-protocol.ts
-import { discoveryKey, sha256 } from "@dxos/crypto";
-import { PublicKey as PublicKey3 } from "@dxos/keys";
-import { log as log8, logInfo as logInfo2 } from "@dxos/log";
-import { MMSTTopology } from "@dxos/network-manager";
-import { Teleport } from "@dxos/teleport";
-import { ReplicatorExtension } from "@dxos/teleport-extension-replicator";
-import { ComplexMap } from "@dxos/util";
+// packages/core/echo/echo-pipeline/src/space/data-pipeline.ts
+import assert8 from "@dxos/node-std/assert";
+import { Event as Event3, scheduleTask as scheduleTask2, synchronized as synchronized3, trackLeaks as trackLeaks2 } from "@dxos/async";
+import { Context as Context3 } from "@dxos/context";
+import { getCredentialAssertion } from "@dxos/credentials";
+import { getStateMachineFromItem, ItemManager } from "@dxos/echo-db";
+import { log as log8 } from "@dxos/log";
+import { Timeframe as Timeframe3 } from "@dxos/timeframe";
 var __decorate5 = function(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")
@@ -916,468 +995,594 @@ var __decorate5 = function(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 MOCK_AUTH_PROVIDER = async (nonce) => Buffer.from("mock");
-var MOCK_AUTH_VERIFIER = async (nonce, credential) => true;
-var SpaceProtocol = class {
-  constructor({ topic, swarmIdentity, networkManager, onSessionAuth }) {
-    this._feeds = /* @__PURE__ */ new Set();
-    this._sessions = new ComplexMap(PublicKey3.hash);
-    this._networkManager = networkManager;
-    this._swarmIdentity = swarmIdentity;
-    this._onSessionAuth = onSessionAuth;
-    this._topic = PublicKey3.from(discoveryKey(sha256(topic.toHex())));
-  }
-  get sessions() {
-    return this._sessions;
+var MESSAGES_PER_SNAPSHOT = 10;
+var AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL = 5e3;
+var TIMEFRAME_SAVE_DEBOUNCE_INTERVAL = 500;
+var DataPipeline = class DataPipeline2 {
+  constructor(_params) {
+    this._params = _params;
+    this._ctx = new Context3();
+    this._lastAutomaticSnapshotTimeframe = new Timeframe3();
+    this._isOpen = false;
+    this._lastTimeframeSaveTime = 0;
+    this._lastSnapshotSaveTime = 0;
+    this.onNewEpoch = new Event3();
   }
-  get feeds() {
-    return this._feeds;
+  get isOpen() {
+    return this._isOpen;
   }
-  get _ownPeerKey() {
-    return this._swarmIdentity.peerKey;
+  get pipeline() {
+    return this._pipeline;
   }
-  // TODO(burdon): Create abstraction for Space (e.g., add keys and have provider).
-  addFeed(feed) {
-    log8("addFeed", {
-      key: feed.key
-    }, {
-      file: "space-protocol.ts",
-      line: 84,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    this._feeds.add(feed);
-    for (const session of this._sessions.values()) {
-      session.replicator.addFeed(feed);
-    }
+  get pipelineState() {
+    var _a;
+    return (_a = this._pipeline) == null ? void 0 : _a.state;
   }
-  async start() {
-    if (this._connection) {
+  setTargetTimeframe(timeframe) {
+    var _a;
+    this._targetTimeframe = timeframe;
+    (_a = this._pipeline) == null ? void 0 : _a.state.setTargetTimeframe(timeframe);
+  }
+  createCredentialProcessor() {
+    return {
+      process: async (credential) => {
+        const assertion = getCredentialAssertion(credential);
+        if (assertion["@type"] !== "dxos.halo.credentials.Epoch") {
+          return;
+        }
+        log8("new epoch", {
+          credential
+        }, {
+          file: "data-pipeline.ts",
+          line: 110,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        await this._processEpoch(assertion);
+        this.currentEpoch = credential;
+        this.onNewEpoch.emit(credential);
+      }
+    };
+  }
+  async open() {
+    if (this._isOpen) {
       return;
     }
-    const credentials = await this._swarmIdentity.credentialProvider(Buffer.from(""));
-    const topologyConfig = {
-      originateConnections: 4,
-      maxPeers: 10,
-      sampleSize: 20
+    this._pipeline = new Pipeline();
+    await this._params.onPipelineCreated(this._pipeline);
+    await this._pipeline.start();
+    await this._pipeline.pause();
+    if (this._targetTimeframe) {
+      this._pipeline.state.setTargetTimeframe(this._targetTimeframe);
+    }
+    const feedWriter = {
+      write: (data, options) => {
+        assert8(this._pipeline, "Pipeline is not initialized.");
+        assert8(this.currentEpoch, "Epoch is not initialized.");
+        return this._pipeline.writer.write({
+          data
+        }, options);
+      }
     };
-    log8("starting...", {}, {
-      file: "space-protocol.ts",
-      line: 107,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    this._connection = await this._networkManager.joinSwarm({
-      protocolProvider: this._createProtocolProvider(credentials),
-      peerId: this._swarmIdentity.peerKey,
-      topic: this._topic,
-      topology: new MMSTTopology(topologyConfig),
-      label: `Protocol swarm: ${this._topic}`
+    this.databaseHost = new DatabaseHost(feedWriter);
+    this.itemManager = new ItemManager(this._params.modelFactory);
+    await this.databaseHost.open(this.itemManager, this._params.modelFactory);
+    scheduleTask2(this._ctx, async () => {
+      await this._consumePipeline();
     });
-    log8("started", {}, {
-      file: "space-protocol.ts",
-      line: 116,
+    this._isOpen = true;
+  }
+  async close() {
+    var _a, _b, _c;
+    if (!this._isOpen) {
+      return;
+    }
+    log8("close", {}, {
+      file: "data-pipeline.ts",
+      line: 162,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-  }
-  async stop() {
-    if (this._connection) {
-      log8("stopping...", {}, {
-        file: "space-protocol.ts",
-        line: 121,
+    this._isOpen = false;
+    await this._ctx.dispose();
+    await ((_a = this._pipeline) == null ? void 0 : _a.stop());
+    try {
+      await this._saveCache();
+      if (this._pipeline) {
+        await this._saveTargetTimeframe(this._pipeline.state.timeframe);
+      }
+    } catch (err) {
+      log8.catch(err, {}, {
+        file: "data-pipeline.ts",
+        line: 175,
         scope: this,
         callSite: (f, a) => f(...a)
       });
-      await this._connection.close();
-      log8("stopped", {}, {
-        file: "space-protocol.ts",
-        line: 123,
+    }
+    await ((_b = this.databaseHost) == null ? void 0 : _b.close());
+    await ((_c = this.itemManager) == null ? void 0 : _c.destroy());
+    await this._params.snapshotManager.close();
+  }
+  async _consumePipeline() {
+    assert8(this._pipeline, "Pipeline is not initialized.");
+    for await (const msg of this._pipeline.consume()) {
+      const { feedKey, seq, data } = msg;
+      log8("processing message", {
+        feedKey,
+        seq
+      }, {
+        file: "data-pipeline.ts",
+        line: 187,
         scope: this,
         callSite: (f, a) => f(...a)
       });
+      try {
+        if (data.payload.data) {
+          const feedInfo = this._params.feedInfoProvider(feedKey);
+          if (!feedInfo) {
+            log8.error("Could not find feed.", {
+              feedKey
+            }, {
+              file: "data-pipeline.ts",
+              line: 193,
+              scope: this,
+              callSite: (f, a) => f(...a)
+            });
+            continue;
+          }
+          await this.databaseHost.echoProcessor({
+            batch: data.payload.data.batch,
+            meta: {
+              feedKey,
+              seq,
+              timeframe: data.timeframe,
+              memberKey: feedInfo.assertion.identityKey
+            }
+          });
+          await this._noteTargetStateIfNeeded(this._pipeline.state.pendingTimeframe);
+        }
+      } catch (err) {
+        log8.catch(err, {}, {
+          file: "data-pipeline.ts",
+          line: 211,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
     }
   }
-  _createProtocolProvider(credentials) {
-    return (wireParams) => {
-      const session = new SpaceProtocolSession({
-        wireParams,
-        swarmIdentity: this._swarmIdentity,
-        onSessionAuth: this._onSessionAuth
+  _createSnapshot() {
+    assert8(this.databaseHost, "Database backend is not initialized.");
+    return {
+      spaceKey: this._params.spaceKey.asUint8Array(),
+      timeframe: this._pipeline.state.timeframe,
+      database: this.databaseHost.createSnapshot()
+    };
+  }
+  async _saveTargetTimeframe(timeframe) {
+    var _a;
+    const newTimeframe = Timeframe3.merge((_a = this._targetTimeframe) != null ? _a : new Timeframe3(), timeframe);
+    await this._params.metadataStore.setSpaceLatestTimeframe(this._params.spaceKey, newTimeframe);
+    this._targetTimeframe = newTimeframe;
+  }
+  async _saveCache() {
+    var _a;
+    const cache = {};
+    try {
+      const propertiesItem = this.itemManager.items.find((item) => {
+        var _a2, _b;
+        return ((_a2 = item.modelMeta) == null ? void 0 : _a2.type) === "dxos:model/document" && ((_b = getStateMachineFromItem(item)) == null ? void 0 : _b.snapshot().type) === "dxos.sdk.client.Properties";
       });
-      this._sessions.set(wireParams.remotePeerId, session);
-      for (const feed of this._feeds) {
-        session.replicator.addFeed(feed);
+      if (propertiesItem) {
+        cache.properties = (_a = getStateMachineFromItem(propertiesItem)) == null ? void 0 : _a.snapshot();
       }
-      return session;
-    };
+    } catch (err) {
+      log8.warn("Failed to cache properties", err, {
+        file: "data-pipeline.ts",
+        line: 245,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    await this._params.metadataStore.setCache(this._params.spaceKey, cache);
   }
-};
-__decorate5([
-  logInfo2
-], SpaceProtocol.prototype, "_topic", void 0);
-__decorate5([
-  logInfo2
-], SpaceProtocol.prototype, "_ownPeerKey", null);
-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 }) {
-    // TODO(dmaretskyi): Start with upload=false when switching it on the fly works.
-    this.replicator = new ReplicatorExtension().setOptions({
-      upload: true
-    });
-    this._authStatus = AuthStatus.INITIAL;
-    this._wireParams = wireParams;
-    this._swarmIdentity = swarmIdentity;
-    this._onSessionAuth = onSessionAuth;
-    this._teleport = new Teleport(wireParams);
+  async _noteTargetStateIfNeeded(timeframe) {
+    if (Date.now() - this._lastTimeframeSaveTime > TIMEFRAME_SAVE_DEBOUNCE_INTERVAL) {
+      this._lastTimeframeSaveTime = Date.now();
+      await this._saveTargetTimeframe(timeframe);
+    }
+    if (Date.now() - this._lastSnapshotSaveTime > AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL && timeframe.totalMessages() - this._lastAutomaticSnapshotTimeframe.totalMessages() > MESSAGES_PER_SNAPSHOT) {
+      await this._saveCache();
+    }
   }
-  get authStatus() {
-    return this._authStatus;
+  async _processEpoch(epoch) {
+    assert8(this._isOpen);
+    assert8(this._pipeline);
+    if (epoch.snapshotCid) {
+      const snapshot = await this._params.snapshotManager.load(epoch.snapshotCid);
+      this.databaseHost._itemDemuxer.restoreFromSnapshot(snapshot.database);
+    }
+    await this._pipeline.pause();
+    await this._pipeline.setCursor(epoch.timeframe);
+    await this._pipeline.unpause();
   }
-  get stream() {
-    return this._teleport.stream;
+  async waitUntilTimeframe(timeframe) {
+    assert8(this._pipeline, "Pipeline is not initialized.");
+    await this._pipeline.state.waitUntilTimeframe(timeframe);
   }
-  async initialize() {
-    await this._teleport.open();
-    this._teleport.addExtension("dxos.mesh.teleport.auth", new AuthExtension({
-      provider: this._swarmIdentity.credentialProvider,
-      verifier: this._swarmIdentity.credentialAuthenticator,
-      onAuthSuccess: () => {
-        var _a;
-        this._authStatus = AuthStatus.SUCCESS;
-        log8("Peer authenticated", {}, {
-          file: "space-protocol.ts",
-          line: 206,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        });
-        (_a = this._onSessionAuth) == null ? void 0 : _a.call(this, this._teleport);
-      },
-      onAuthFailure: () => {
-        log8.warn("Auth failed", {}, {
-          file: "space-protocol.ts",
-          line: 211,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        });
-        this._authStatus = AuthStatus.FAILURE;
-      }
-    }));
-    this._teleport.addExtension("dxos.mesh.teleport.replicator", this.replicator);
+  async createEpoch() {
+    assert8(this._pipeline);
+    assert8(this.currentEpoch);
+    await this._pipeline.pause();
+    const snapshot = await this._createSnapshot();
+    const snapshotCid = await this._params.snapshotManager.store(snapshot);
+    const epoch = {
+      previousId: this.currentEpoch.id,
+      timeframe: this._pipeline.state.timeframe,
+      number: this.currentEpoch.subject.assertion.number + 1,
+      snapshotCid
+    };
+    await this._pipeline.unpause();
+    return epoch;
   }
-  async destroy() {
-    await this._teleport.close();
+  async ensureEpochInitialized() {
+    await this.onNewEpoch.waitForCondition(() => !!this.currentEpoch);
   }
 };
 __decorate5([
-  logInfo2
-], SpaceProtocolSession.prototype, "_wireParams", void 0);
+  synchronized3
+], DataPipeline.prototype, "open", null);
 __decorate5([
-  logInfo2
-], SpaceProtocolSession.prototype, "authStatus", null);
+  synchronized3
+], DataPipeline.prototype, "close", null);
+__decorate5([
+  synchronized3
+], DataPipeline.prototype, "_processEpoch", null);
+__decorate5([
+  synchronized3
+], DataPipeline.prototype, "createEpoch", null);
+DataPipeline = __decorate5([
+  trackLeaks2("open", "close")
+], DataPipeline);
 
-// packages/core/echo/echo-pipeline/src/space/space-manager.ts
-import { synchronized as synchronized4, trackLeaks as trackLeaks2 } from "@dxos/async";
-import { failUndefined } from "@dxos/debug";
-import { PublicKey as PublicKey4 } from "@dxos/keys";
+// packages/core/echo/echo-pipeline/src/space/space.ts
+import assert9 from "@dxos/node-std/assert";
+import { Event as Event4, synchronized as synchronized4, trackLeaks as trackLeaks3, Lock } from "@dxos/async";
+import { log as log10, logInfo } from "@dxos/log";
+import { AdmittedFeed as AdmittedFeed2 } from "@dxos/protocols/proto/dxos/halo/credentials";
+import { Callback as Callback2 } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/space/control-pipeline.ts
+import { SpaceStateMachine } from "@dxos/credentials";
+import { PublicKey as PublicKey3 } from "@dxos/keys";
 import { log as log9 } from "@dxos/log";
-import { trace } from "@dxos/protocols";
-import { ComplexMap as ComplexMap2 } from "@dxos/util";
-var __decorate6 = function(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 SpaceManager = class SpaceManager2 {
-  constructor({ feedStore, networkManager }) {
-    this._spaces = new ComplexMap2(PublicKey4.hash);
-    this._instanceId = PublicKey4.random().toHex();
-    this._feedStore = feedStore;
-    this._networkManager = networkManager;
+import { AdmittedFeed } from "@dxos/protocols/proto/dxos/halo/credentials";
+import { Callback } from "@dxos/util";
+var ControlPipeline = class {
+  constructor({ spaceKey, genesisFeed, feedProvider }) {
+    this.onFeedAdmitted = new Callback();
+    this._pipeline = new Pipeline();
+    void this._pipeline.addFeed(genesisFeed);
+    this._spaceStateMachine = new SpaceStateMachine(spaceKey);
+    this._spaceStateMachine.onFeedAdmitted.set(async (info) => {
+      log9("feed admitted", {
+        key: info.key
+      }, {
+        file: "control-pipeline.ts",
+        line: 39,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      if (info.assertion.designation === AdmittedFeed.Designation.CONTROL && !info.key.equals(genesisFeed.key)) {
+        try {
+          const feed = await feedProvider(info.key);
+          await this._pipeline.addFeed(feed);
+        } catch (err) {
+          log9.catch(err, {}, {
+            file: "control-pipeline.ts",
+            line: 47,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      }
+      await this.onFeedAdmitted.callIfSet(info);
+    });
+    this.onMemberAdmitted = this._spaceStateMachine.onMemberAdmitted;
+    this.onCredentialProcessed = this._spaceStateMachine.onCredentialProcessed;
   }
-  // TODO(burdon): Remove.
-  get spaces() {
-    return this._spaces;
+  get spaceState() {
+    return this._spaceStateMachine;
   }
-  async open() {
-    log9.trace("dxos.echo.space-manager", trace.begin({
-      id: this._instanceId,
-      parentId: this._traceParent
-    }), {
-      file: "space-manager.ts",
-      line: 66,
+  get pipeline() {
+    return this._pipeline;
+  }
+  setWriteFeed(feed) {
+    this._pipeline.setWriteFeed(feed);
+  }
+  async start() {
+    log9("starting...", {}, {
+      file: "control-pipeline.ts",
+      line: 71,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-  }
-  async close() {
-    await Promise.all([
-      ...this._spaces.values()
-    ].map((space) => space.close()));
-    log9.trace("dxos.echo.space-manager", trace.end({
-      id: this._instanceId
-    }), {
-      file: "space-manager.ts",
-      line: 72,
+    setTimeout(async () => {
+      for await (const msg of this._pipeline.consume()) {
+        try {
+          log9("processing", {
+            key: msg.feedKey,
+            seq: msg.seq
+          }, {
+            file: "control-pipeline.ts",
+            line: 76,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          if (msg.data.payload.credential) {
+            const result = await this._spaceStateMachine.process(msg.data.payload.credential.credential, PublicKey3.from(msg.feedKey));
+            if (!result) {
+              log9.warn("processing failed", {
+                msg
+              }, {
+                file: "control-pipeline.ts",
+                line: 83,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+            }
+          }
+        } catch (err) {
+          log9.catch(err, {}, {
+            file: "control-pipeline.ts",
+            line: 87,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    await this._pipeline.start();
+    log9("started", {}, {
+      file: "control-pipeline.ts",
+      line: 93,
       scope: this,
       callSite: (f, a) => f(...a)
     });
   }
-  async constructSpace({ metadata, swarmIdentity, onNetworkConnection }) {
-    var _a;
-    log9("constructing space...", {
-      spaceKey: metadata.genesisFeedKey
-    }, {
-      file: "space-manager.ts",
-      line: 76,
+  async stop() {
+    log9("stopping...", {}, {
+      file: "control-pipeline.ts",
+      line: 97,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-    const genesisFeed = await this._feedStore.openFeed((_a = metadata.genesisFeedKey) != null ? _a : failUndefined());
-    const spaceKey = metadata.key;
-    const protocol = new SpaceProtocol({
-      topic: spaceKey,
-      swarmIdentity,
-      networkManager: this._networkManager,
-      onSessionAuth: onNetworkConnection
-    });
-    const space = new Space({
-      spaceKey,
-      protocol,
-      genesisFeed,
-      feedProvider: (feedKey) => this._feedStore.openFeed(feedKey)
+    await this._pipeline.stop();
+    log9("stopped", {}, {
+      file: "control-pipeline.ts",
+      line: 99,
+      scope: this,
+      callSite: (f, a) => f(...a)
     });
-    this._spaces.set(space.key, space);
-    return space;
   }
 };
-__decorate6([
-  synchronized4
-], SpaceManager.prototype, "open", null);
-__decorate6([
-  synchronized4
-], SpaceManager.prototype, "close", null);
-SpaceManager = __decorate6([
-  trackLeaks2("open", "close")
-], SpaceManager);
 
-// packages/core/echo/echo-pipeline/src/space/genesis.ts
-import { createCredential } from "@dxos/credentials";
-import { failUndefined as failUndefined2 } from "@dxos/debug";
-import { AdmittedFeed as AdmittedFeed3, SpaceMember } from "@dxos/protocols/proto/dxos/halo/credentials";
-var spaceGenesis = async (keyring, signingContext, space) => {
-  var _a, _b, _c;
-  const credentials = [
-    await createCredential({
-      signer: keyring,
-      issuer: space.key,
-      subject: space.key,
-      assertion: {
-        "@type": "dxos.halo.credentials.SpaceGenesis",
-        spaceKey: space.key
-      }
-    }),
-    await createCredential({
-      signer: keyring,
-      issuer: space.key,
-      subject: signingContext.identityKey,
-      assertion: {
-        "@type": "dxos.halo.credentials.SpaceMember",
-        spaceKey: space.key,
-        role: SpaceMember.Role.ADMIN,
-        profile: signingContext.profile,
-        genesisFeedKey: (_a = space.controlFeedKey) != null ? _a : failUndefined2()
-      }
-    }),
-    await signingContext.credentialSigner.createCredential({
-      subject: (_b = space.controlFeedKey) != null ? _b : failUndefined2(),
-      assertion: {
-        "@type": "dxos.halo.credentials.AdmittedFeed",
-        spaceKey: space.key,
-        identityKey: signingContext.identityKey,
-        deviceKey: signingContext.deviceKey,
-        designation: AdmittedFeed3.Designation.CONTROL
-      }
-    }),
-    await signingContext.credentialSigner.createCredential({
-      subject: (_c = space.dataFeedKey) != null ? _c : failUndefined2(),
-      assertion: {
-        "@type": "dxos.halo.credentials.AdmittedFeed",
-        spaceKey: space.key,
-        identityKey: signingContext.identityKey,
-        deviceKey: signingContext.deviceKey,
-        designation: AdmittedFeed3.Designation.DATA
+// packages/core/echo/echo-pipeline/src/space/space.ts
+var __decorate6 = function(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 Space = class Space2 {
+  constructor(params) {
+    this._addFeedLock = new Lock();
+    this.onCredentialProcessed = new Callback2();
+    this.stateUpdate = new Event4();
+    // Processes epoch credentials.
+    this._dataPipelineCredentialConsumer = void 0;
+    this._isOpen = false;
+    assert9(params.spaceKey && params.feedProvider);
+    this._key = params.spaceKey;
+    this._genesisFeedKey = params.genesisFeed.key;
+    this._feedProvider = params.feedProvider;
+    this._snapshotManager = params.snapshotManager;
+    this._controlPipeline = new ControlPipeline({
+      spaceKey: params.spaceKey,
+      genesisFeed: params.genesisFeed,
+      feedProvider: params.feedProvider
+    });
+    this._controlPipeline.onFeedAdmitted.set(async (info) => {
+      if (info.assertion.designation === AdmittedFeed2.Designation.DATA) {
+        await this._addFeedLock.executeSynchronized(async () => {
+          if (this._dataPipeline.pipeline) {
+            if (!this._dataPipeline.pipeline.hasFeed(info.key)) {
+              return this._dataPipeline.pipeline.addFeed(await this._feedProvider(info.key));
+            }
+          }
+        });
       }
-    })
-  ];
-  for (const credential of credentials) {
-    await space.controlPipeline.writer.write({
-      credential: {
-        credential
+      if (!info.key.equals(params.genesisFeed.key)) {
+        this.protocol.addFeed(await params.feedProvider(info.key));
       }
     });
-  }
-  return credentials;
-};
-
-// packages/core/echo/echo-pipeline/src/dbhost/data-service-host.ts
-import assert7 from "@dxos/node-std/assert";
-import { Stream } from "@dxos/codec-protobuf";
-import { tagMutationsInBatch, setMetadataOnObject } from "@dxos/echo-db";
-import { log as log10 } from "@dxos/log";
-import { ComplexMap as ComplexMap3 } from "@dxos/util";
-var DataServiceHost = class {
-  constructor(_itemManager, _itemDemuxer, _writeStream) {
-    this._itemManager = _itemManager;
-    this._itemDemuxer = _itemDemuxer;
-    this._writeStream = _writeStream;
-    this._clientTagMap = new ComplexMap3(([feedKey, seq]) => `${feedKey.toHex()}:${seq}`);
-  }
-  /**
-  * Real-time subscription to data objects in a space.
-  */
-  subscribe() {
-    return new Stream(({ next, ctx }) => {
-      const objects = Array.from(this._itemManager.entities.values()).map((entity) => entity.createSnapshot());
-      next({
-        batch: {
-          objects
-        }
-      });
-      this._itemDemuxer.mutation.on(ctx, (message) => {
-        var _a;
-        const { batch, meta } = message;
-        log10("message", {
-          batch,
-          meta
-        }, {
-          file: "data-service-host.ts",
-          line: 49,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        });
-        const clientTag = this._clientTagMap.get([
-          message.meta.feedKey,
-          message.meta.seq
-        ]);
-        (_a = batch.objects) == null ? void 0 : _a.forEach((object) => {
-          setMetadataOnObject(object, meta);
-        });
-        if (clientTag) {
-          tagMutationsInBatch(batch, clientTag);
-        }
-        next({
-          clientTag,
-          feedKey: message.meta.feedKey,
-          seq: message.meta.seq,
-          batch
-        });
+    this._controlPipeline.onCredentialProcessed.set(async (credential) => {
+      await this.onCredentialProcessed.callIfSet(credential);
+      log10("onCredentialProcessed", {
+        credential
+      }, {
+        file: "space.ts",
+        line: 106,
+        scope: this,
+        callSite: (f, a) => f(...a)
       });
+      this.stateUpdate.emit();
     });
-  }
-  async write(request) {
-    var _a, _b, _c;
-    assert7(this._writeStream, "Cannot write mutations in readonly mode");
-    log10("write", {
-      clientTag: request.clientTag,
-      objectCount: (_b = (_a = request.batch.objects) == null ? void 0 : _a.length) != null ? _b : 0
-    }, {
-      file: "data-service-host.ts",
-      line: 77,
-      scope: this,
-      callSite: (f, a) => f(...a)
-    });
-    const message = {
-      batch: {
-        objects: (_c = request.batch.objects) == null ? void 0 : _c.map((object) => {
-          var _a2;
-          return {
-            ...object,
-            mutations: (_a2 = object.mutations) == null ? void 0 : _a2.map((mutation) => ({
-              ...mutation,
-              meta: void 0
-            })),
-            meta: void 0
-          };
-        })
-      }
-    };
-    const receipt = await this._writeStream.write(message, {
-      afterWrite: async (receipt2) => {
-        if (request.clientTag) {
-          log10("tag", {
-            clientTag: request.clientTag,
-            feedKey: receipt2.feedKey,
-            seq: receipt2.seq
-          }, {
-            file: "data-service-host.ts",
-            line: 96,
-            scope: this,
-            callSite: (f, a) => f(...a)
-          });
-          this._clientTagMap.set([
-            receipt2.feedKey,
-            receipt2.seq
-          ], request.clientTag);
+    this.protocol = params.protocol;
+    this.protocol.addFeed(params.genesisFeed);
+    this._dataPipeline = new DataPipeline({
+      modelFactory: params.modelFactory,
+      metadataStore: params.metadataStore,
+      snapshotManager: params.snapshotManager,
+      memberKey: params.memberKey,
+      spaceKey: this._key,
+      feedInfoProvider: (feedKey) => this._controlPipeline.spaceState.feeds.get(feedKey),
+      snapshotId: params.snapshotId,
+      onPipelineCreated: async (pipeline) => {
+        if (this._dataFeed) {
+          pipeline.setWriteFeed(this._dataFeed);
         }
+        await this._addFeedLock.executeSynchronized(async () => {
+          for (const feed of this._controlPipeline.spaceState.feeds.values()) {
+            if (feed.assertion.designation === AdmittedFeed2.Designation.DATA && !pipeline.hasFeed(feed.key)) {
+              await pipeline.addFeed(await this._feedProvider(feed.key));
+            }
+          }
+        });
       }
     });
-    return receipt;
   }
-};
-
-// packages/core/echo/echo-pipeline/src/dbhost/database-host.ts
-import { ItemDemuxer } from "@dxos/echo-db";
-var DatabaseHost = class {
-  constructor(_outboundStream, _snapshot) {
-    this._outboundStream = _outboundStream;
-    this._snapshot = _snapshot;
+  get key() {
+    return this._key;
   }
-  get isReadOnly() {
-    return !!this._outboundStream;
+  get isOpen() {
+    return this._isOpen;
   }
-  get echoProcessor() {
-    return this._echoProcessor;
+  get genesisFeedKey() {
+    return this._genesisFeedKey;
   }
-  async open(itemManager, modelFactory) {
-    this._itemManager = itemManager;
-    this._itemManager._debugLabel = "host";
-    this._itemDemuxer = new ItemDemuxer(itemManager, modelFactory);
-    this._echoProcessor = this._itemDemuxer.open();
-    if (this._snapshot) {
-      this._itemDemuxer.restoreFromSnapshot(this._snapshot);
-    }
+  get controlFeedKey() {
+    var _a;
+    return (_a = this._controlFeed) == null ? void 0 : _a.key;
+  }
+  get dataFeedKey() {
+    var _a;
+    return (_a = this._dataFeed) == null ? void 0 : _a.key;
+  }
+  get spaceState() {
+    return this._controlPipeline.spaceState;
+  }
+  /**
+  * @test-only
+  */
+  get controlPipeline() {
+    return this._controlPipeline.pipeline;
+  }
+  get dataPipeline() {
+    return this._dataPipeline;
+  }
+  get snapshotManager() {
+    return this._snapshotManager;
+  }
+  setControlFeed(feed) {
+    assert9(!this._controlFeed, "Control feed already set.");
+    this._controlFeed = feed;
+    this._controlPipeline.setWriteFeed(feed);
+    return this;
   }
-  async close() {
+  setDataFeed(feed) {
+    var _a;
+    assert9(!this._dataFeed, "Data feed already set.");
+    this._dataFeed = feed;
+    (_a = this._dataPipeline.pipeline) == null ? void 0 : _a.setWriteFeed(feed);
+    return this;
   }
-  getWriteStream() {
-    return this._outboundStream;
+  /**
+  * Use for diagnostics.
+  */
+  getControlFeeds() {
+    return Array.from(this._controlPipeline.spaceState.feeds.values());
   }
-  createSnapshot() {
-    return this._itemDemuxer.createSnapshot();
+  /**
+  * Use for diagnostics.
+  */
+  // getDataFeeds(): FeedInfo[] {
+  //   return this._dataPipeline?.getFeeds();
+  // }
+  async open() {
+    log10("opening...", {}, {
+      file: "space.ts",
+      line: 208,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (this._isOpen) {
+      return;
+    }
+    await this._controlPipeline.start();
+    await this.protocol.start();
+    this._dataPipelineCredentialConsumer = this._controlPipeline.spaceState.registerProcessor(this._dataPipeline.createCredentialProcessor());
+    this._isOpen = true;
+    log10("opened", {}, {
+      file: "space.ts",
+      line: 222,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
   }
-  createDataServiceHost() {
+  async close() {
     var _a;
-    return new DataServiceHost(this._itemManager, this._itemDemuxer, (_a = this._outboundStream) != null ? _a : void 0);
+    log10("closing...", {
+      key: this._key
+    }, {
+      file: "space.ts",
+      line: 227,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (!this._isOpen) {
+      return;
+    }
+    await ((_a = this._dataPipelineCredentialConsumer) == null ? void 0 : _a.close());
+    this._dataPipelineCredentialConsumer = void 0;
+    await this._dataPipeline.close();
+    await this.protocol.stop();
+    await this._controlPipeline.stop();
+    this._isOpen = false;
+    log10("closed", {}, {
+      file: "space.ts",
+      line: 241,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async initializeDataPipeline() {
+    log10.info("initializeDataPipeline", {}, {
+      file: "space.ts",
+      line: 245,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    assert9(this._isOpen, "Space must be open to initialize data pipeline.");
+    await this._dataPipeline.open();
+    await this._dataPipelineCredentialConsumer.open();
   }
 };
+__decorate6([
+  logInfo
+], Space.prototype, "key", null);
+__decorate6([
+  synchronized4
+], Space.prototype, "open", null);
+__decorate6([
+  synchronized4
+], Space.prototype, "close", null);
+Space = __decorate6([
+  trackLeaks3("open", "close")
+], Space);
 
-// packages/core/echo/echo-pipeline/src/dbhost/snapshot-manager.ts
-import { trackLeaks as trackLeaks3 } from "@dxos/async";
-import { schema as schema4 } from "@dxos/protocols";
-import { ObjectSync } from "@dxos/teleport-extension-object-sync";
+// packages/core/echo/echo-pipeline/src/space/space-protocol.ts
+import { discoveryKey, sha256 } from "@dxos/crypto";
+import { PublicKey as PublicKey4 } from "@dxos/keys";
+import { log as log11, logInfo as logInfo2 } from "@dxos/log";
+import { MMSTTopology } from "@dxos/network-manager";
+import { Teleport } from "@dxos/teleport";
+import { ReplicatorExtension } from "@dxos/teleport-extension-replicator";
+import { ComplexMap as ComplexMap4 } from "@dxos/util";
 var __decorate7 = function(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")
@@ -1388,154 +1593,180 @@ var __decorate7 = function(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 SnapshotManager = class SnapshotManager2 {
-  // prettier-ignore
-  constructor(_snapshotStore) {
-    this._snapshotStore = _snapshotStore;
-    this._objectSync = new ObjectSync({
-      getObject: async (id) => {
-        const snapshot = await this._snapshotStore.loadSnapshot(id);
-        if (!snapshot) {
-          return void 0;
-        }
-        return {
-          id,
-          payload: schema4.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").encodeAsAny(snapshot)
-        };
-      },
-      setObject: async (data) => {
-        const snapshot = schema4.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(data.payload);
-        await this._snapshotStore.saveSnapshot(snapshot);
-      }
-    });
-  }
-  get objectSync() {
-    return this._objectSync;
-  }
-  async open() {
-    await this._objectSync.open();
-  }
-  async close() {
-    await this._objectSync.close();
+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 }) {
+    this._feeds = /* @__PURE__ */ new Set();
+    this._sessions = new ComplexMap4(PublicKey4.hash);
+    this._networkManager = networkManager;
+    this._swarmIdentity = swarmIdentity;
+    this._onSessionAuth = onSessionAuth;
+    this._topic = PublicKey4.from(discoveryKey(sha256(topic.toHex())));
   }
-  async load(id) {
-    const local = await this._snapshotStore.loadSnapshot(id);
-    if (local) {
-      return local;
-    }
-    const remote = await this._objectSync.download(id);
-    return schema4.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(remote.payload);
+  get sessions() {
+    return this._sessions;
   }
-  async store(snapshot) {
-    const id = await this._snapshotStore.saveSnapshot(snapshot);
-    return id;
+  get feeds() {
+    return this._feeds;
   }
-};
-SnapshotManager = __decorate7([
-  trackLeaks3("open", "close")
-], SnapshotManager);
-
-// packages/core/echo/echo-pipeline/src/dbhost/snapshot-store.ts
-import { subtleCrypto } from "@dxos/crypto";
-import { schema as schema5 } from "@dxos/protocols";
-var SnapshotStore = class {
-  // prettier-ignore
-  constructor(_directory) {
-    this._directory = _directory;
+  get _ownPeerKey() {
+    return this._swarmIdentity.peerKey;
   }
-  async saveSnapshot(snapshot) {
-    const encoded = schema5.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").encode(snapshot);
-    const key = await subtleCrypto.digest("SHA-256", encoded);
-    const keyString = Buffer.from(key).toString("hex");
-    const file = await this._directory.getOrCreateFile(keyString);
-    try {
-      await file.write(0, Buffer.from(encoded));
-    } finally {
-      await file.close();
+  // TODO(burdon): Create abstraction for Space (e.g., add keys and have provider).
+  addFeed(feed) {
+    log11("addFeed", {
+      key: feed.key
+    }, {
+      file: "space-protocol.ts",
+      line: 84,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._feeds.add(feed);
+    for (const session of this._sessions.values()) {
+      session.replicator.addFeed(feed);
     }
-    return keyString;
   }
-  async loadSnapshot(key) {
-    const file = await this._directory.getOrCreateFile(key);
-    try {
-      const { size } = await file.stat();
-      if (size === 0) {
-        return void 0;
-      }
-      const buffer = await file.read(0, size);
-      return schema5.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(buffer);
-    } finally {
-      await file.close();
+  async start() {
+    if (this._connection) {
+      return;
     }
-  }
-};
-
-// packages/core/echo/echo-pipeline/src/dbhost/data-service.ts
-import assert8 from "@dxos/node-std/assert";
-import { raise } from "@dxos/debug";
-import { PublicKey as PublicKey5 } from "@dxos/keys";
-import { log as log11 } from "@dxos/log";
-import { ComplexMap as ComplexMap4 } from "@dxos/util";
-var DataServiceSubscriptions = class {
-  constructor() {
-    this._spaces = new ComplexMap4(PublicKey5.hash);
-  }
-  clear() {
-    this._spaces.clear();
-  }
-  registerSpace(spaceKey, host) {
-    log11("Registering space", {
-      spaceKey
-    }, {
-      file: "data-service.ts",
-      line: 31,
+    const credentials = await this._swarmIdentity.credentialProvider(Buffer.from(""));
+    const topologyConfig = {
+      originateConnections: 4,
+      maxPeers: 10,
+      sampleSize: 20
+    };
+    log11("starting...", {}, {
+      file: "space-protocol.ts",
+      line: 107,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-    this._spaces.set(spaceKey, host);
-  }
-  unregisterSpace(spaceKey) {
-    log11("Unregistering space", {
-      spaceKey
-    }, {
-      file: "data-service.ts",
-      line: 36,
+    this._connection = await this._networkManager.joinSwarm({
+      protocolProvider: this._createProtocolProvider(credentials),
+      peerId: this._swarmIdentity.peerKey,
+      topic: this._topic,
+      topology: new MMSTTopology(topologyConfig),
+      label: `Protocol swarm: ${this._topic}`
+    });
+    log11("started", {}, {
+      file: "space-protocol.ts",
+      line: 116,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-    this._spaces.delete(spaceKey);
   }
-  getDataService(spaceKey) {
-    return this._spaces.get(spaceKey);
+  async stop() {
+    if (this._connection) {
+      log11("stopping...", {}, {
+        file: "space-protocol.ts",
+        line: 121,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this._connection.close();
+      log11("stopped", {}, {
+        file: "space-protocol.ts",
+        line: 123,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+  }
+  _createProtocolProvider(credentials) {
+    return (wireParams) => {
+      const session = new SpaceProtocolSession({
+        wireParams,
+        swarmIdentity: this._swarmIdentity,
+        onSessionAuth: this._onSessionAuth
+      });
+      this._sessions.set(wireParams.remotePeerId, session);
+      for (const feed of this._feeds) {
+        session.replicator.addFeed(feed);
+      }
+      return session;
+    };
+  }
+};
+__decorate7([
+  logInfo2
+], SpaceProtocol.prototype, "_topic", void 0);
+__decorate7([
+  logInfo2
+], SpaceProtocol.prototype, "_ownPeerKey", null);
+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 }) {
+    // TODO(dmaretskyi): Start with upload=false when switching it on the fly works.
+    this.replicator = new ReplicatorExtension().setOptions({
+      upload: true
+    });
+    this._authStatus = AuthStatus.INITIAL;
+    this._wireParams = wireParams;
+    this._swarmIdentity = swarmIdentity;
+    this._onSessionAuth = onSessionAuth;
+    this._teleport = new Teleport(wireParams);
+  }
+  get authStatus() {
+    return this._authStatus;
   }
-};
-var DataServiceImpl = class {
-  constructor(_subscriptions) {
-    this._subscriptions = _subscriptions;
+  get stream() {
+    return this._teleport.stream;
   }
-  subscribe(request) {
-    var _a;
-    assert8(request.spaceKey);
-    const host = (_a = this._subscriptions.getDataService(request.spaceKey)) != null ? _a : raise(new Error(`space not found: ${request.spaceKey}`));
-    return host.subscribe();
+  async initialize() {
+    await this._teleport.open();
+    this._teleport.addExtension("dxos.mesh.teleport.auth", new AuthExtension({
+      provider: this._swarmIdentity.credentialProvider,
+      verifier: this._swarmIdentity.credentialAuthenticator,
+      onAuthSuccess: () => {
+        var _a;
+        this._authStatus = AuthStatus.SUCCESS;
+        log11("Peer authenticated", {}, {
+          file: "space-protocol.ts",
+          line: 206,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        (_a = this._onSessionAuth) == null ? void 0 : _a.call(this, this._teleport);
+      },
+      onAuthFailure: () => {
+        log11.warn("Auth failed", {}, {
+          file: "space-protocol.ts",
+          line: 211,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        this._authStatus = AuthStatus.FAILURE;
+      }
+    }));
+    this._teleport.addExtension("dxos.mesh.teleport.replicator", this.replicator);
   }
-  write(request) {
-    var _a;
-    assert8(request.spaceKey);
-    assert8(request.batch);
-    const host = (_a = this._subscriptions.getDataService(request.spaceKey)) != null ? _a : raise(new Error(`space not found: ${request.spaceKey}`));
-    return host.write(request);
+  async destroy() {
+    await this._teleport.close();
   }
 };
+__decorate7([
+  logInfo2
+], SpaceProtocolSession.prototype, "_wireParams", void 0);
+__decorate7([
+  logInfo2
+], SpaceProtocolSession.prototype, "authStatus", null);
 
-// packages/core/echo/echo-pipeline/src/space/data-pipeline.ts
-import assert9 from "@dxos/node-std/assert";
-import { scheduleTask as scheduleTask2, synchronized as synchronized5, trackLeaks as trackLeaks4 } from "@dxos/async";
-import { Context as Context3 } from "@dxos/context";
-import { failUndefined as failUndefined3 } from "@dxos/debug";
-import { ItemManager } from "@dxos/echo-db";
+// packages/core/echo/echo-pipeline/src/space/space-manager.ts
+import { synchronized as synchronized5, trackLeaks as trackLeaks4 } from "@dxos/async";
+import { failUndefined as failUndefined2 } from "@dxos/debug";
+import { PublicKey as PublicKey5 } from "@dxos/keys";
 import { log as log12 } from "@dxos/log";
-import { Timeframe as Timeframe3 } from "@dxos/timeframe";
+import { trace } from "@dxos/protocols";
+import { ComplexMap as ComplexMap5 } from "@dxos/util";
 var __decorate8 = function(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")
@@ -1546,204 +1777,85 @@ var __decorate8 = function(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 MESSAGES_PER_SNAPSHOT = 10;
-var AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL = 5e3;
-var TIMEFRAME_SAVE_DEBOUNCE_INTERVAL = 500;
-var DISABLE_SNAPSHOT_CACHE = true;
-var DataPipeline = class DataPipeline2 {
-  constructor(_params) {
-    this._params = _params;
-    this._ctx = new Context3();
-    this._lastAutomaticSnapshotTimeframe = new Timeframe3();
-    this._isOpen = false;
-    this._lastTimeframeSaveTime = 0;
-    this._lastSnapshotSaveTime = 0;
-  }
-  get isOpen() {
-    return this._isOpen;
+var SpaceManager = class SpaceManager2 {
+  constructor({ feedStore, networkManager, modelFactory, metadataStore, snapshotStore }) {
+    this._spaces = new ComplexMap5(PublicKey5.hash);
+    this._instanceId = PublicKey5.random().toHex();
+    this._feedStore = feedStore;
+    this._networkManager = networkManager;
+    this._modelFactory = modelFactory;
+    this._metadataStore = metadataStore;
+    this._snapshotStore = snapshotStore;
   }
-  get pipelineState() {
-    var _a;
-    return (_a = this._pipeline) == null ? void 0 : _a.state;
+  // TODO(burdon): Remove.
+  get spaces() {
+    return this._spaces;
   }
-  get snapshotTimeframe() {
-    var _a;
-    return (_a = this._snapshot) == null ? void 0 : _a.timeframe;
+  async open() {
   }
-  getStartTimeframe() {
-    var _a;
-    return snapshotTimeframeToStartingTimeframe((_a = this.snapshotTimeframe) != null ? _a : new Timeframe3());
+  async close() {
+    await Promise.all([
+      ...this._spaces.values()
+    ].map((space) => space.close()));
   }
-  setTargetTimeframe(timeframe) {
+  async constructSpace({ metadata, swarmIdentity, onNetworkConnection, memberKey }) {
     var _a;
-    this._targetTimeframe = timeframe;
-    (_a = this._pipeline) == null ? void 0 : _a.state.setTargetTimeframe(timeframe);
-  }
-  async open(spaceContext) {
-    var _a, _b, _c, _d;
-    if (this._isOpen) {
-      return;
-    }
-    this._spaceContext = spaceContext;
-    if (this._params.snapshotId && !DISABLE_SNAPSHOT_CACHE) {
-      this._snapshot = await this._params.snapshotManager.load(this._params.snapshotId);
-      this._lastAutomaticSnapshotTimeframe = (_b = (_a = this._snapshot) == null ? void 0 : _a.timeframe) != null ? _b : new Timeframe3();
-    }
-    this._pipeline = await this._spaceContext.openPipeline(this.getStartTimeframe());
-    if (this._targetTimeframe) {
-      this._pipeline.state.setTargetTimeframe(this._targetTimeframe);
-    }
-    const feedWriter = createMappedFeedWriter((data) => ({
-      data
-    }), (_c = this._pipeline.writer) != null ? _c : failUndefined3());
-    this.databaseBackend = new DatabaseHost(feedWriter, (_d = this._snapshot) == null ? void 0 : _d.database);
-    this._itemManager = new ItemManager(this._params.modelFactory);
-    await this.databaseBackend.open(this._itemManager, this._params.modelFactory);
-    scheduleTask2(this._ctx, async () => {
-      await this._consumePipeline();
+    log12.trace("dxos.echo.space-manager.construct-space", trace.begin({
+      id: this._instanceId
+    }), {
+      file: "space-manager.ts",
+      line: 74,
+      scope: this,
+      callSite: (f, a) => f(...a)
     });
-    this._isOpen = true;
-  }
-  async close() {
-    var _a, _b, _c;
-    if (!this._isOpen) {
-      return;
-    }
-    log12("close", {}, {
-      file: "data-pipeline.ts",
-      line: 145,
+    log12("constructing space...", {
+      spaceKey: metadata.genesisFeedKey
+    }, {
+      file: "space-manager.ts",
+      line: 75,
       scope: this,
       callSite: (f, a) => f(...a)
     });
-    this._isOpen = false;
-    await this._ctx.dispose();
-    await ((_a = this._pipeline) == null ? void 0 : _a.stop());
-    try {
-      if (this._pipeline) {
-        await this._saveTargetTimeframe(this._pipeline.state.timeframe);
-        if (!DISABLE_SNAPSHOT_CACHE) {
-          await this._saveSnapshot(this._pipeline.state.timeframe);
-        }
-      }
-    } catch (err) {
-      log12.catch(err, {}, {
-        file: "data-pipeline.ts",
-        line: 160,
-        scope: this,
-        callSite: (f, a) => f(...a)
-      });
-    }
-    await ((_b = this.databaseBackend) == null ? void 0 : _b.close());
-    await ((_c = this._itemManager) == null ? void 0 : _c.destroy());
-    await this._params.snapshotManager.close();
-  }
-  async _consumePipeline() {
-    assert9(this._pipeline, "Pipeline is not initialized.");
-    for await (const msg of this._pipeline.consume()) {
-      const { feedKey, seq, data } = msg;
-      log12("processing message", {
-        msg
-      }, {
-        file: "data-pipeline.ts",
-        line: 172,
-        scope: this,
-        callSite: (f, a) => f(...a)
-      });
-      try {
-        if (data.payload.data) {
-          const feedInfo = this._params.feedInfoProvider(feedKey);
-          if (!feedInfo) {
-            log12.error("Could not find feed.", {
-              feedKey
-            }, {
-              file: "data-pipeline.ts",
-              line: 178,
-              scope: this,
-              callSite: (f, a) => f(...a)
-            });
-            continue;
-          }
-          await this.databaseBackend.echoProcessor({
-            batch: data.payload.data.batch,
-            meta: {
-              feedKey,
-              seq,
-              timeframe: data.timeframe,
-              memberKey: feedInfo.assertion.identityKey
-            }
-          });
-          await this._noteTargetStateIfNeeded(this._pipeline.state.pendingTimeframe);
-        }
-      } catch (err) {
-        log12.catch(err, {}, {
-          file: "data-pipeline.ts",
-          line: 196,
-          scope: this,
-          callSite: (f, a) => f(...a)
-        });
-      }
-    }
-  }
-  _createSnapshot(timeframe) {
-    assert9(this.databaseBackend, "Database backend is not initialized.");
-    return {
-      spaceKey: this._params.spaceKey.asUint8Array(),
-      timeframe,
-      database: this.databaseBackend.createSnapshot()
-    };
-  }
-  async _saveSnapshot(timeframe) {
-    const snapshot = await this._createSnapshot(timeframe);
-    const snapshotKey = await this._params.snapshotManager.store(snapshot);
-    await this._params.metadataStore.setSpaceSnapshot(this._params.spaceKey, snapshotKey);
-    return snapshot;
-  }
-  async _saveTargetTimeframe(timeframe) {
-    var _a;
-    const newTimeframe = Timeframe3.merge((_a = this._targetTimeframe) != null ? _a : new Timeframe3(), timeframe);
-    await this._params.metadataStore.setSpaceLatestTimeframe(this._params.spaceKey, newTimeframe);
-    this._targetTimeframe = newTimeframe;
-  }
-  async _noteTargetStateIfNeeded(timeframe) {
-    var _a;
-    if (Date.now() - this._lastTimeframeSaveTime > TIMEFRAME_SAVE_DEBOUNCE_INTERVAL) {
-      this._lastTimeframeSaveTime = Date.now();
-      await this._saveTargetTimeframe(timeframe);
-    }
-    if (!DISABLE_SNAPSHOT_CACHE && Date.now() - this._lastSnapshotSaveTime > AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL && timeframe.totalMessages() - this._lastAutomaticSnapshotTimeframe.totalMessages() > MESSAGES_PER_SNAPSHOT) {
-      this._lastSnapshotSaveTime = Date.now();
-      const snapshot = await this._saveSnapshot(timeframe);
-      this._lastAutomaticSnapshotTimeframe = (_a = snapshot.timeframe) != null ? _a : failUndefined3();
-      log12("save", {
-        snapshot
-      }, {
-        file: "data-pipeline.ts",
-        line: 239,
-        scope: this,
-        callSite: (f, a) => f(...a)
-      });
-    }
-  }
-  async waitUntilTimeframe(timeframe) {
-    assert9(this._pipeline, "Pipeline is not initialized.");
-    await this._pipeline.state.waitUntilTimeframe(timeframe);
+    const genesisFeed = await this._feedStore.openFeed((_a = metadata.genesisFeedKey) != null ? _a : failUndefined2());
+    const spaceKey = metadata.key;
+    const protocol = new SpaceProtocol({
+      topic: spaceKey,
+      swarmIdentity,
+      networkManager: this._networkManager,
+      onSessionAuth: onNetworkConnection
+    });
+    const snapshotManager = new SnapshotManager(this._snapshotStore);
+    const space = new Space({
+      spaceKey,
+      protocol,
+      genesisFeed,
+      feedProvider: (feedKey) => this._feedStore.openFeed(feedKey),
+      modelFactory: this._modelFactory,
+      metadataStore: this._metadataStore,
+      snapshotManager,
+      memberKey
+    });
+    this._spaces.set(space.key, space);
+    log12.trace("dxos.echo.space-manager.construct-space", trace.end({
+      id: this._instanceId
+    }), {
+      file: "space-manager.ts",
+      line: 100,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return space;
   }
 };
 __decorate8([
   synchronized5
-], DataPipeline.prototype, "open", null);
+], SpaceManager.prototype, "open", null);
 __decorate8([
   synchronized5
-], DataPipeline.prototype, "close", null);
-DataPipeline = __decorate8([
+], SpaceManager.prototype, "close", null);
+SpaceManager = __decorate8([
   trackLeaks4("open", "close")
-], DataPipeline);
-var snapshotTimeframeToStartingTimeframe = (snapshotTimeframe) => {
-  return snapshotTimeframe.map(([key, seq]) => [
-    key,
-    seq + 1
-  ]);
-};
+], SpaceManager);
 
 export {
   STORAGE_VERSION,
@@ -1757,20 +1869,19 @@ export {
   TimeframeClock,
   Pipeline,
   AuthExtension,
-  Space,
-  MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER,
-  SpaceProtocol,
-  AuthStatus,
-  SpaceProtocolSession,
-  SpaceManager,
-  spaceGenesis,
   DataServiceHost,
   DatabaseHost,
   SnapshotManager,
   SnapshotStore,
   DataServiceSubscriptions,
   DataServiceImpl,
-  DataPipeline
+  DataPipeline,
+  Space,
+  MOCK_AUTH_PROVIDER,
+  MOCK_AUTH_VERIFIER,
+  SpaceProtocol,
+  AuthStatus,
+  SpaceProtocolSession,
+  SpaceManager
 };
-//# sourceMappingURL=chunk-4YAT2XJW.mjs.map
+//# sourceMappingURL=chunk-2NGLSBL4.mjs.map