@dxos/echo-pipeline 0.1.24-next.6b1f434

package/dist/lib/browser/chunk-3GAE5CKD.mjs

@@ -0,0 +1,1621 @@
+import "@dxos/node-std/globals"
+
+// packages/core/echo/echo-pipeline/src/metadata/metadata-store.ts
+import assert from "@dxos/node-std/assert";
+import { synchronized } from "@dxos/async";
+import { log } from "@dxos/log";
+import { schema } from "@dxos/protocols";
+var __decorate = 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 STORAGE_VERSION = 1;
+var emptyEchoMetadata = () => ({
+  version: STORAGE_VERSION,
+  spaces: [],
+  created: new Date(),
+  updated: new Date()
+});
+var MetadataStore = class {
+  // prettier-ignore
+  constructor(_directory) {
+    this._directory = _directory;
+    this._metadata = emptyEchoMetadata();
+  }
+  get version() {
+    var _a;
+    return (_a = this._metadata.version) != null ? _a : 0;
+  }
+  /**
+  * Returns a list of currently saved spaces. The list and objects in it can be modified addSpace and
+  * addSpaceFeed functions.
+  */
+  get spaces() {
+    var _a;
+    return (_a = this._metadata.spaces) != null ? _a : [];
+  }
+  /**
+  * Loads metadata from persistent storage.
+  */
+  async load() {
+    const file = this._directory.getOrCreateFile("EchoMetadata");
+    try {
+      const { size: fileLength } = await file.stat();
+      if (fileLength < 4) {
+        return;
+      }
+      const dataSize = fromBytesInt32(await file.read(0, 4));
+      log("loaded", {
+        size: dataSize
+      }, {
+        file: "metadata-store.ts",
+        line: 68,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      {
+        if (fileLength < dataSize + 4) {
+          throw new Error("Metadata storage is corrupted");
+        }
+      }
+      const data = await file.read(4, dataSize);
+      this._metadata = schema.getCodecForType("dxos.echo.metadata.EchoMetadata").decode(data);
+    } catch (err) {
+      log.error("failed to load metadata", {
+        err
+      }, {
+        file: "metadata-store.ts",
+        line: 80,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this._metadata = emptyEchoMetadata();
+    } finally {
+      await file.close();
+    }
+  }
+  async _save() {
+    var _a;
+    const data = {
+      ...this._metadata,
+      version: STORAGE_VERSION,
+      created: (_a = this._metadata.created) != null ? _a : new Date(),
+      updated: new Date()
+    };
+    const file = this._directory.getOrCreateFile("EchoMetadata");
+    try {
+      const encoded = Buffer.from(schema.getCodecForType("dxos.echo.metadata.EchoMetadata").encode(data));
+      await file.write(0, toBytesInt32(encoded.length));
+      log("saved", {
+        size: encoded.length
+      }, {
+        file: "metadata-store.ts",
+        line: 103,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await file.write(4, encoded);
+    } finally {
+      await file.close();
+    }
+  }
+  /**
+  * Clears storage - doesn't work for now.
+  */
+  async clear() {
+    log("clearing all metadata", {}, {
+      file: "metadata-store.ts",
+      line: 116,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._directory.delete();
+  }
+  getIdentityRecord() {
+    return this._metadata.identity;
+  }
+  async setIdentityRecord(record) {
+    assert(!this._metadata.identity, "Cannot overwrite existing identity in metadata");
+    this._metadata.identity = record;
+    await this._save();
+  }
+  async addSpace(record) {
+    var _a, _b, _c;
+    assert(!((_a = this._metadata.spaces) != null ? _a : []).find((space) => space.key === record.key), "Cannot overwrite existing space in metadata");
+    ((_c = (_b = this._metadata).spaces) != null ? _c : _b.spaces = []).push(record);
+    await this._save();
+  }
+  async setSpaceLatestTimeframe(spaceKey, timeframe) {
+    const space = this.spaces.find((space2) => space2.key === spaceKey);
+    assert(space, "Space not found");
+    space.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;
+    await this._save();
+  }
+  async setWritableFeedKeys(spaceKey, controlFeedKey, dataFeedKey) {
+    const space = this.spaces.find((space2) => space2.key === spaceKey);
+    assert(space, "Space not found");
+    space.controlFeedKey = controlFeedKey;
+    space.dataFeedKey = dataFeedKey;
+    await this._save();
+  }
+};
+__decorate([
+  synchronized
+], MetadataStore.prototype, "load", null);
+__decorate([
+  synchronized
+], MetadataStore.prototype, "_save", null);
+var toBytesInt32 = (num) => {
+  const buf = Buffer.alloc(4);
+  buf.writeInt32LE(num, 0);
+  return buf;
+};
+var fromBytesInt32 = (buf) => buf.readInt32LE(0);
+
+// packages/core/echo/echo-pipeline/src/common/codec.ts
+import { createCodecEncoding } from "@dxos/hypercore";
+import { schema as schema2 } from "@dxos/protocols";
+var codec = schema2.getCodecForType("dxos.echo.feed.FeedMessage");
+var valueEncoding = createCodecEncoding(codec);
+
+// packages/core/echo/echo-pipeline/src/common/feeds.ts
+import assert2 from "@dxos/node-std/assert";
+var createMappedFeedWriter = (mapper, writer) => {
+  assert2(mapper);
+  assert2(writer);
+  return {
+    write: async (data) => await writer.write(await mapper(data))
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/pipeline/timeframe-clock.ts
+import { Event } from "@dxos/async";
+import { timed } from "@dxos/debug";
+import { log as log2 } from "@dxos/log";
+import { Timeframe } from "@dxos/timeframe";
+var __decorate2 = 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 mapTimeframeToFeedIndexes = (timeframe) => timeframe.frames().map(([feedKey, index]) => ({
+  feedKey,
+  index
+}));
+var mapFeedIndexesToTimeframe = (indexes) => new Timeframe(indexes.map(({ feedKey, index }) => [
+  feedKey,
+  index
+]));
+var TimeframeClock = class {
+  // prettier-ignore
+  constructor(_timeframe = new Timeframe()) {
+    this._timeframe = _timeframe;
+    this.update = new Event();
+  }
+  get timeframe() {
+    return this._timeframe;
+  }
+  updateTimeframe(key, seq) {
+    this._timeframe = Timeframe.merge(this._timeframe, new Timeframe([
+      [
+        key,
+        seq
+      ]
+    ]));
+    this.update.emit(this._timeframe);
+  }
+  hasGaps(timeframe) {
+    const gaps = Timeframe.dependencies(timeframe, this._timeframe);
+    return !gaps.isEmpty();
+  }
+  async waitUntilReached(target) {
+    log2.debug("waitUntilReached", {
+      target,
+      current: this._timeframe
+    }, {
+      file: "timeframe-clock.ts",
+      line: 45,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this.update.waitForCondition(() => {
+      log2("check if reached", {
+        target,
+        current: this._timeframe,
+        deps: Timeframe.dependencies(target, this._timeframe)
+      }, {
+        file: "timeframe-clock.ts",
+        line: 47,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return Timeframe.dependencies(target, this._timeframe).isEmpty();
+    });
+  }
+};
+__decorate2([
+  timed(5e3)
+], TimeframeClock.prototype, "waitUntilReached", null);
+
+// packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
+import assert4 from "@dxos/node-std/assert";
+import { sleep, Trigger } from "@dxos/async";
+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";
+
+// packages/core/echo/echo-pipeline/src/pipeline/message-selector.ts
+import debug from "debug";
+import assert3 from "@dxos/node-std/assert";
+var log3 = debug("dxos:echo-db:message-selector");
+var createMessageSelector = (timeframeClock) => {
+  return (messages) => {
+    for (let i = 0; i < messages.length; i++) {
+      const { data: { timeframe } } = messages[i];
+      assert3(timeframe);
+      if (!timeframeClock.hasGaps(timeframe)) {
+        return i;
+      }
+    }
+    log3("Skipping...");
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
+var PipelineState = class {
+  // prettier-ignore
+  constructor(_iterator, _timeframeClock) {
+    this._iterator = _iterator;
+    this._timeframeClock = _timeframeClock;
+    this.timeframeUpdate = this._timeframeClock.update;
+  }
+  /**
+  * Latest theoretical timeframe based on the last mutation in each feed.
+  * NOTE: This might never be reached if the mutation dependencies
+  */
+  get endTimeframe() {
+    return mapFeedIndexesToTimeframe(this._iterator.feeds.filter((feed) => feed.properties.length > 0).map((feed) => ({
+      feedKey: feed.key,
+      index: feed.properties.length - 1
+    })));
+  }
+  get timeframe() {
+    return this._timeframeClock.timeframe;
+  }
+  get targetTimeframe() {
+    return this._targetTimeframe ? Timeframe2.merge(this.endTimeframe, this._targetTimeframe) : this.endTimeframe;
+  }
+  async waitUntilTimeframe(target) {
+    await this._timeframeClock.waitUntilReached(target);
+  }
+  setTargetTimeframe(target) {
+    this._targetTimeframe = target;
+  }
+  /**
+  * Wait until the pipeline processes all messages in the feed and reaches the target timeframe if that is set.
+  *
+  * This function will resolve immediately if the pipeline is stalled.
+  *
+  * @param timeout Timeout in milliseconds to specify the maximum wait time.
+  */
+  async waitUntilReachedTargetTimeframe({ timeout } = {}) {
+    var _a;
+    log4("waitUntilReachedTargetTimeframe", {
+      timeout,
+      current: this.timeframe,
+      target: this.targetTimeframe
+    }, {
+      file: "pipeline.ts",
+      line: 82,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    (_a = this._reachedTargetPromise) != null ? _a : this._reachedTargetPromise = Promise.race([
+      this._timeframeClock.update.waitForCondition(() => {
+        return Timeframe2.dependencies(this.targetTimeframe, this.timeframe).isEmpty();
+      }),
+      this._iterator.stalled.discardParameter().waitForCount(1)
+    ]);
+    let done = false;
+    if (timeout) {
+      return Promise.race([
+        this._reachedTargetPromise.then(() => {
+          done = true;
+        }),
+        sleep(timeout).then(() => {
+          if (done) {
+            return;
+          }
+          log4.warn("waitUntilReachedTargetTimeframe timed out", {
+            timeout,
+            current: this.timeframe,
+            target: this.targetTimeframe,
+            dependencies: Timeframe2.dependencies(this.targetTimeframe, this.timeframe)
+          }, {
+            file: "pipeline.ts",
+            line: 107,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        })
+      ]);
+    } else {
+      return this._reachedTargetPromise;
+    }
+  }
+};
+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: mapTimeframeToFeedIndexes(this._initialTimeframe),
+      stallTimeout: 1e3
+    });
+    this._state = new PipelineState(this._feedSetIterator, this._timeframeClock);
+    this._processingTrigger = new Trigger().wake();
+    this._isOpen = false;
+    this._feedSetIterator.stalled.on((iterator) => {
+      log4.warn(`Stalled after ${iterator.options.stallTimeout}ms with ${iterator.size} feeds.`, {}, {
+        file: "pipeline.ts",
+        line: 183,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  get writer() {
+    assert4(this._writer, "Writer not set.");
+    return this._writer;
+  }
+  getFeeds() {
+    return this._feedSetIterator.feeds;
+  }
+  async addFeed(feed) {
+    await this._feedSetIterator.addFeed(feed);
+  }
+  setWriteFeed(feed) {
+    assert4(!this._writer, "Writer already set.");
+    assert4(feed.properties.writable, "Feed must be writable.");
+    this._writer = createMappedFeedWriter((payload) => ({
+      timeframe: this._timeframeClock.timeframe,
+      payload
+    }), feed.createFeedWriter());
+  }
+  async start() {
+    log4("starting...", {}, {
+      file: "pipeline.ts",
+      line: 218,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._feedSetIterator.open();
+    log4("started", {}, {
+      file: "pipeline.ts",
+      line: 220,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    log4("stopping...", {}, {
+      file: "pipeline.ts",
+      line: 224,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._feedSetIterator.close();
+    await this._processingTrigger.wait();
+    log4("stopped", {}, {
+      file: "pipeline.ts",
+      line: 227,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  /**
+  * Starts to iterate over the ordered messages from the added feeds.
+  * Updates the timeframe clock after the message has bee processed.
+  */
+  async *consume() {
+    assert4(!this._isOpen, "Pipeline is already being consumed.");
+    this._isOpen = true;
+    for await (const block of this._feedSetIterator) {
+      this._processingTrigger.reset();
+      yield block;
+      this._processingTrigger.wake();
+      this._timeframeClock.updateTimeframe(PublicKey.from(block.feedKey), block.seq);
+    }
+    this._isOpen = false;
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/space/auth.ts
+import assert5 from "@dxos/node-std/assert";
+import { runInContext, scheduleTask } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { randomBytes } from "@dxos/crypto";
+import { log as log5 } from "@dxos/log";
+import { schema as schema3 } from "@dxos/protocols";
+import { RpcExtension } from "@dxos/teleport";
+var AuthExtension = class extends RpcExtension {
+  constructor(_authParams) {
+    super({
+      requested: {
+        AuthService: schema3.getService("dxos.mesh.teleport.auth.AuthService")
+      },
+      exposed: {
+        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 Context({
+      onError: (err) => {
+        log5.catch(err, {}, {
+          file: "auth.ts",
+          line: 29,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
+    });
+  }
+  async getHandlers() {
+    return {
+      AuthService: {
+        authenticate: async ({ challenge }) => {
+          try {
+            const credential = await this._authParams.provider(challenge);
+            if (!credential) {
+              throw new Error("auth rejected");
+            }
+            return {
+              credential
+            };
+          } catch (err) {
+            log5.error("failed to generate auth credentials", err, {
+              file: "auth.ts",
+              line: 56,
+              scope: this,
+              callSite: (f, a) => f(...a)
+            });
+            throw new Error("auth rejected");
+          }
+        }
+      }
+    };
+  }
+  async onOpen(context) {
+    await super.onOpen(context);
+    scheduleTask(this._ctx, async () => {
+      try {
+        const challenge = randomBytes(32);
+        const { credential } = await this.rpc.AuthService.authenticate({
+          challenge
+        });
+        assert5((credential == null ? void 0 : credential.length) > 0, "invalid credential");
+        const success = await this._authParams.verifier(challenge, credential);
+        assert5(success, "credential not verified");
+        runInContext(this._ctx, () => this._authParams.onAuthSuccess());
+      } catch (err) {
+        log5.warn("auth failed", err, {
+          file: "auth.ts",
+          line: 75,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        this.close();
+        this._authParams.onAuthFailure();
+      }
+    });
+  }
+  async onClose() {
+    await this._ctx.dispose();
+    await super.onClose();
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/space/space.ts
+import assert6 from "@dxos/node-std/assert";
+import { Event as Event2, synchronized as synchronized2, trackLeaks } 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 { 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)
+      });
+      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)
+          });
+        }
+      }
+      await this.onFeedAdmitted.callIfSet(info);
+    });
+    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,
+      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
+          }, {
+            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,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    await this._pipeline.start();
+    log6("started", {}, {
+      file: "control-pipeline.ts",
+      line: 95,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  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/space/space.ts
+var __decorate3 = 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({ spaceKey, protocol, genesisFeed, feedProvider }) {
+    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) {
+        if (this._dataPipeline) {
+          await this._dataPipeline.addFeed(await feedProvider(info.key));
+        }
+      }
+      if (!info.key.equals(genesisFeed.key)) {
+        this.protocol.addFeed(await feedProvider(info.key));
+      }
+    });
+    this._controlPipeline.onCredentialProcessed.set(async (credential) => {
+      await this.onCredentialProcessed.callIfSet(credential);
+      log7("onCredentialProcessed", {
+        credential
+      }, {
+        file: "space.ts",
+        line: 74,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      this.stateUpdate.emit();
+    });
+    this.protocol = protocol;
+    this.protocol.addFeed(genesisFeed);
+  }
+  get key() {
+    return this._key;
+  }
+  get isOpen() {
+    return this._isOpen;
+  }
+  get genesisFeedKey() {
+    return this._genesisFeedKey;
+  }
+  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;
+  }
+  setControlFeed(feed) {
+    assert6(!this._controlFeed, "Control feed already set.");
+    this._controlFeed = feed;
+    this._controlPipeline.setWriteFeed(feed);
+    return this;
+  }
+  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;
+  }
+  /**
+  * Use for diagnostics.
+  */
+  getControlFeeds() {
+    return Array.from(this._controlPipeline.spaceState.feeds.values());
+  }
+  /**
+  * Use for diagnostics.
+  */
+  // getDataFeeds(): FeedInfo[] {
+  //   return this._dataPipeline?.getFeeds();
+  // }
+  async open() {
+    log7("opening...", {}, {
+      file: "space.ts",
+      line: 145,
+      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: 155,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async close() {
+    var _a;
+    log7("closing...", {
+      key: this._key
+    }, {
+      file: "space.ts",
+      line: 160,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    if (!this._isOpen) {
+      return;
+    }
+    await this.protocol.stop();
+    await ((_a = this._dataPipelineController) == null ? void 0 : _a.close());
+    await this._controlPipeline.stop();
+    this._isOpen = false;
+    log7("closed", {}, {
+      file: "space.ts",
+      line: 171,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async initDataPipeline(controller) {
+    assert6(this._isOpen, "Space must be open to initialize data pipeline.");
+    assert6(!this._dataPipelineController, "Data pipeline already initialized.");
+    assert6(!this._dataPipeline, "Data pipeline already initialized.");
+    this._dataPipelineController = controller;
+    await this._dataPipelineController.open({
+      openPipeline: async (start) => {
+        assert6(!this._dataPipeline, "Data pipeline already initialized.");
+        this._dataPipeline = new Pipeline(start);
+        if (this._dataFeed) {
+          this._dataPipeline.setWriteFeed(this._dataFeed);
+        }
+        for (const feed of this._controlPipeline.spaceState.feeds.values()) {
+          if (feed.assertion.designation === AdmittedFeed2.Designation.DATA) {
+            await this._dataPipeline.addFeed(await this._feedProvider(feed.key));
+          }
+        }
+        await this._dataPipeline.start();
+        return this._dataPipeline;
+      }
+    });
+  }
+};
+__decorate3([
+  logInfo
+], Space.prototype, "key", null);
+__decorate3([
+  synchronized2
+], Space.prototype, "open", null);
+__decorate3([
+  synchronized2
+], Space.prototype, "close", null);
+Space = __decorate3([
+  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";
+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
+    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 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;
+  }
+  get feeds() {
+    return this._feeds;
+  }
+  get _ownPeerKey() {
+    return this._swarmIdentity.peerKey;
+  }
+  // TODO(burdon): Create abstraction for Space (e.g., add keys and have provider).
+  addFeed(feed) {
+    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);
+    }
+  }
+  async start() {
+    if (this._connection) {
+      return;
+    }
+    const credentials = await this._swarmIdentity.credentialProvider(Buffer.from(""));
+    const topologyConfig = {
+      originateConnections: 4,
+      maxPeers: 10,
+      sampleSize: 20
+    };
+    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}`
+    });
+    log8("started", {}, {
+      file: "space-protocol.ts",
+      line: 116,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    if (this._connection) {
+      log8("stopping...", {}, {
+        file: "space-protocol.ts",
+        line: 121,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this._connection.close();
+      log8("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;
+    };
+  }
+};
+__decorate4([
+  logInfo2
+], SpaceProtocol.prototype, "_topic", void 0);
+__decorate4([
+  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;
+  }
+  get stream() {
+    return this._teleport.stream;
+  }
+  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 destroy() {
+    await this._teleport.close();
+  }
+};
+__decorate4([
+  logInfo2
+], SpaceProtocolSession.prototype, "_wireParams", void 0);
+__decorate4([
+  logInfo2
+], SpaceProtocolSession.prototype, "authStatus", null);
+
+// packages/core/echo/echo-pipeline/src/space/space-manager.ts
+import { synchronized as synchronized3, trackLeaks as trackLeaks2 } from "@dxos/async";
+import { failUndefined } from "@dxos/debug";
+import { PublicKey as PublicKey4 } from "@dxos/keys";
+import { log as log9 } from "@dxos/log";
+import { ComplexMap as ComplexMap2 } from "@dxos/util";
+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")
+    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._feedStore = feedStore;
+    this._networkManager = networkManager;
+  }
+  // TODO(burdon): Remove.
+  get spaces() {
+    return this._spaces;
+  }
+  async open() {
+  }
+  async close() {
+    await Promise.all([
+      ...this._spaces.values()
+    ].map((space) => space.close()));
+  }
+  async constructSpace({ metadata, swarmIdentity, onNetworkConnection }) {
+    var _a;
+    log9("constructing space...", {
+      spaceKey: metadata.genesisFeedKey
+    }, {
+      file: "space-manager.ts",
+      line: 70,
+      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)
+    });
+    this._spaces.set(space.key, space);
+    return space;
+  }
+};
+__decorate5([
+  synchronized3
+], SpaceManager.prototype, "open", null);
+__decorate5([
+  synchronized3
+], SpaceManager.prototype, "close", null);
+SpaceManager = __decorate5([
+  trackLeaks2("open", "close")
+], SpaceManager);
+
+// packages/core/echo/echo-pipeline/src/space/genesis.ts
+import { CredentialGenerator } from "@dxos/credentials";
+import { failUndefined as failUndefined2 } from "@dxos/debug";
+import { AdmittedFeed as AdmittedFeed3 } from "@dxos/protocols/proto/dxos/halo/credentials";
+var spaceGenesis = async (keyring, signingContext, space) => {
+  var _a, _b;
+  const generator = new CredentialGenerator(keyring, signingContext.identityKey, signingContext.deviceKey);
+  const credentials = [
+    ...await generator.createSpaceGenesis(space.key, (_a = space.controlFeedKey) != null ? _a : failUndefined2(), signingContext.profile),
+    await generator.createFeedAdmission(space.key, (_b = space.dataFeedKey) != null ? _b : failUndefined2(), AdmittedFeed3.Designation.DATA)
+  ];
+  for (const credential of credentials) {
+    await space.controlPipeline.writer.write({
+      credential: {
+        credential
+      }
+    });
+  }
+  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 } 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, (mutation) => {
+        var _a;
+        log10("Object update", {
+          mutation
+        }, {
+          file: "data-service-host.ts",
+          line: 49,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        const clientTag = this._clientTagMap.get([
+          mutation.meta.feedKey,
+          mutation.meta.seq
+        ]);
+        const batch = {
+          objects: [
+            {
+              ...mutation.data,
+              mutations: (_a = mutation.data.mutations) == null ? void 0 : _a.map((m, mutationIdx) => ({
+                ...m,
+                meta: mutation.meta
+              })),
+              meta: mutation.meta
+            }
+          ]
+        };
+        if (clientTag) {
+          tagMutationsInBatch(batch, clientTag);
+        }
+        next({
+          clientTag,
+          feedKey: mutation.meta.feedKey,
+          seq: mutation.meta.seq,
+          batch
+        });
+      });
+    });
+  }
+  async write(request) {
+    var _a, _b;
+    assert7(this._writeStream, "Cannot write mutations in readonly mode");
+    assert7(((_a = request.batch.objects) == null ? void 0 : _a.length) === 1, "Only single object mutations are supported");
+    const receipt = await this._writeStream.write({
+      object: {
+        ...request.batch.objects[0],
+        mutations: (_b = request.batch.objects[0].mutations) == null ? void 0 : _b.map((m) => ({
+          ...m,
+          meta: void 0
+        })),
+        meta: void 0
+      }
+    });
+    if (request.clientTag) {
+      this._clientTagMap.set([
+        receipt.feedKey,
+        receipt.seq
+      ], request.clientTag);
+    }
+    return receipt;
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/dbhost/database-backend.ts
+import { ItemDemuxer } from "@dxos/echo-db";
+var DatabaseBackendHost = class {
+  constructor(_outboundStream, _snapshot, _options = {}) {
+    this._outboundStream = _outboundStream;
+    this._snapshot = _snapshot;
+    this._options = _options;
+  }
+  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._options);
+    this._echoProcessor = this._itemDemuxer.open();
+    if (this._snapshot) {
+      await this._itemDemuxer.restoreFromSnapshot(this._snapshot);
+    }
+  }
+  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/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";
+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 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();
+  }
+  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);
+  }
+  async store(snapshot) {
+    const id = await this._snapshotStore.saveSnapshot(snapshot);
+    return id;
+  }
+};
+SnapshotManager = __decorate6([
+  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;
+  }
+  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;
+  }
+  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();
+    }
+  }
+};
+
+// 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,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._spaces.set(spaceKey, host);
+  }
+  unregisterSpace(spaceKey) {
+    log11("Unregistering space", {
+      spaceKey
+    }, {
+      file: "data-service.ts",
+      line: 36,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._spaces.delete(spaceKey);
+  }
+  getDataService(spaceKey) {
+    return this._spaces.get(spaceKey);
+  }
+};
+var DataServiceImpl = class {
+  constructor(_subscriptions) {
+    this._subscriptions = _subscriptions;
+  }
+  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();
+  }
+  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);
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/space/data-pipeline-controller.ts
+import assert9 from "@dxos/node-std/assert";
+import { Event as Event3, scheduleTask as scheduleTask2, trackLeaks as trackLeaks4 } from "@dxos/async";
+import { Context as Context2 } from "@dxos/context";
+import { failUndefined as failUndefined3 } from "@dxos/debug";
+import { ItemManager } from "@dxos/echo-db";
+import { log as log12 } from "@dxos/log";
+import { Timeframe as Timeframe3 } from "@dxos/timeframe";
+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")
+    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 NoopDataPipelineController = class {
+  async open(context) {
+  }
+  async close() {
+  }
+};
+var MESSAGES_PER_SNAPSHOT = 10;
+var AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL = 5e3;
+var TIMEFRAME_SAVE_DEBOUNCE_INTERVAL = 500;
+var DataPipelineControllerImpl = class DataPipelineControllerImpl2 {
+  constructor(_params) {
+    this._params = _params;
+    this._ctx = new Context2();
+    this._lastAutomaticSnapshotTimeframe = new Timeframe3();
+    this.onTimeframeReached = new Event3();
+  }
+  get pipelineState() {
+    var _a;
+    return (_a = this._pipeline) == null ? void 0 : _a.state;
+  }
+  get snapshotTimeframe() {
+    var _a;
+    return (_a = this._snapshot) == null ? void 0 : _a.timeframe;
+  }
+  getStartTimeframe() {
+    var _a;
+    return snapshotTimeframeToStartingTimeframe((_a = this.snapshotTimeframe) != null ? _a : new Timeframe3());
+  }
+  async open(spaceContext) {
+    var _a, _b, _c, _d;
+    this._spaceContext = spaceContext;
+    if (this._params.snapshotId) {
+      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());
+    const feedWriter = createMappedFeedWriter((data) => ({
+      data
+    }), (_c = this._pipeline.writer) != null ? _c : failUndefined3());
+    this.databaseBackend = new DatabaseBackendHost(feedWriter, (_d = this._snapshot) == null ? void 0 : _d.database, {
+      snapshots: true
+      // TODO(burdon): Config.
+    });
+    this._itemManager = new ItemManager(this._params.modelFactory);
+    await this.databaseBackend.open(this._itemManager, this._params.modelFactory);
+    scheduleTask2(this._ctx, async () => {
+      await this._consumePipeline();
+    });
+    this._createPeriodicSnapshots();
+  }
+  _createPeriodicSnapshots() {
+    this.onTimeframeReached.debounce(TIMEFRAME_SAVE_DEBOUNCE_INTERVAL).on(this._ctx, async () => {
+      await this._saveLatestTimeframe();
+    });
+    this.onTimeframeReached.debounce(AUTOMATIC_SNAPSHOT_DEBOUNCE_INTERVAL).on(this._ctx, async () => {
+      var _a, _b;
+      const latestTimeframe = (_a = this._pipeline) == null ? void 0 : _a.state.timeframe;
+      if (!latestTimeframe) {
+        return;
+      }
+      if (latestTimeframe.totalMessages() - this._lastAutomaticSnapshotTimeframe.totalMessages() > MESSAGES_PER_SNAPSHOT) {
+        const snapshot = await this._saveSnapshot();
+        this._lastAutomaticSnapshotTimeframe = (_b = snapshot.timeframe) != null ? _b : failUndefined3();
+        log12("save", {
+          snapshot
+        }, {
+          file: "data-pipeline-controller.ts",
+          line: 151,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
+    });
+  }
+  async _saveSnapshot() {
+    const snapshot = await this.createSnapshot();
+    const snapshotKey = await this._params.snapshotManager.store(snapshot);
+    await this._params.metadataStore.setSpaceSnapshot(this._params.spaceKey, snapshotKey);
+    return snapshot;
+  }
+  async _saveLatestTimeframe() {
+    var _a;
+    const latestTimeframe = (_a = this._pipeline) == null ? void 0 : _a.state.timeframe;
+    if (latestTimeframe) {
+      await this._params.metadataStore.setSpaceLatestTimeframe(this._params.spaceKey, latestTimeframe);
+    }
+  }
+  async close() {
+    var _a, _b, _c;
+    try {
+      await this._saveLatestTimeframe();
+      await this._saveSnapshot();
+    } catch (err) {
+      log12.catch(err, {}, {
+        file: "data-pipeline-controller.ts",
+        line: 175,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    await this._ctx.dispose();
+    await ((_a = this._pipeline) == null ? void 0 : _a.stop());
+    await ((_b = this.databaseBackend) == null ? void 0 : _b.close());
+    await ((_c = this._itemManager) == null ? void 0 : _c.destroy());
+    await this._params.snapshotManager.close();
+  }
+  createSnapshot() {
+    var _a, _b;
+    return {
+      spaceKey: this._params.spaceKey.asUint8Array(),
+      timeframe: (_b = (_a = this._pipeline) == null ? void 0 : _a.state.timeframe) != null ? _b : new Timeframe3(),
+      database: this.databaseBackend.createSnapshot()
+    };
+  }
+  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-controller.ts",
+        line: 196,
+        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-controller.ts",
+              line: 202,
+              scope: this,
+              callSite: (f, a) => f(...a)
+            });
+            continue;
+          }
+          await this.databaseBackend.echoProcessor({
+            data: data.payload.data.object,
+            meta: {
+              feedKey,
+              seq,
+              timeframe: data.timeframe,
+              memberKey: feedInfo.assertion.identityKey
+            }
+          });
+          this.onTimeframeReached.emit(data.timeframe);
+        }
+      } catch (err) {
+        log12.catch(err, {}, {
+          file: "data-pipeline-controller.ts",
+          line: 218,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
+    }
+  }
+  async waitUntilTimeframe(timeframe) {
+    assert9(this._pipeline, "Pipeline is not initialized.");
+    await this._pipeline.state.waitUntilTimeframe(timeframe);
+  }
+};
+DataPipelineControllerImpl = __decorate7([
+  trackLeaks4("open", "close")
+], DataPipelineControllerImpl);
+var snapshotTimeframeToStartingTimeframe = (snapshotTimeframe) => {
+  return snapshotTimeframe.map(([key, seq]) => [
+    key,
+    seq + 1
+  ]);
+};
+
+export {
+  STORAGE_VERSION,
+  MetadataStore,
+  codec,
+  valueEncoding,
+  createMappedFeedWriter,
+  mapTimeframeToFeedIndexes,
+  mapFeedIndexesToTimeframe,
+  TimeframeClock,
+  Pipeline,
+  AuthExtension,
+  Space,
+  MOCK_AUTH_PROVIDER,
+  MOCK_AUTH_VERIFIER,
+  SpaceProtocol,
+  AuthStatus,
+  SpaceProtocolSession,
+  SpaceManager,
+  spaceGenesis,
+  DataServiceHost,
+  DatabaseBackendHost,
+  SnapshotManager,
+  SnapshotStore,
+  DataServiceSubscriptions,
+  DataServiceImpl,
+  NoopDataPipelineController,
+  DataPipelineControllerImpl
+};
+//# sourceMappingURL=chunk-3GAE5CKD.mjs.map