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

package/dist/lib/node/testing/index.cjs

@@ -0,0 +1,1835 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/core/echo/echo-pipeline/src/testing/index.ts
+var testing_exports = {};
+__export(testing_exports, {
+  MemoryNetworkManagerProvider: () => MemoryNetworkManagerProvider,
+  TestAgent: () => TestAgent,
+  TestAgentBuilder: () => TestAgentBuilder,
+  TestFeedBuilder: () => TestFeedBuilder,
+  WebsocketNetworkManagerProvider: () => WebsocketNetworkManagerProvider,
+  createMemoryDatabase: () => createMemoryDatabase,
+  createRemoteDatabaseFromDataServiceHost: () => createRemoteDatabaseFromDataServiceHost,
+  testLocalDatabase: () => testLocalDatabase
+});
+module.exports = __toCommonJS(testing_exports);
+
+// packages/core/echo/echo-pipeline/src/testing/test-agent-builder.ts
+var import_document_model = require("@dxos/document-model");
+var import_keys6 = require("@dxos/keys");
+var import_messaging = require("@dxos/messaging");
+var import_model_factory = require("@dxos/model-factory");
+var import_network_manager2 = require("@dxos/network-manager");
+var import_random_access_storage = require("@dxos/random-access-storage");
+var import_teleport_extension_presence = require("@dxos/teleport-extension-presence");
+var import_util7 = require("@dxos/util");
+
+// packages/core/echo/echo-pipeline/src/dbhost/data-service-host.ts
+var import_node_assert = __toESM(require("node:assert"));
+var import_codec_protobuf = require("@dxos/codec-protobuf");
+var import_echo_db = require("@dxos/echo-db");
+var import_log = require("@dxos/log");
+var import_util = require("@dxos/util");
+var DataServiceHost = class {
+  constructor(_itemManager, _itemDemuxer, _writeStream) {
+    this._itemManager = _itemManager;
+    this._itemDemuxer = _itemDemuxer;
+    this._writeStream = _writeStream;
+    this._clientTagMap = new import_util.ComplexMap(([feedKey, seq]) => `${feedKey.toHex()}:${seq}`);
+  }
+  /**
+  * Real-time subscription to data objects in a space.
+  */
+  subscribe() {
+    return new import_codec_protobuf.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;
+        (0, import_log.log)("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) {
+          (0, import_echo_db.tagMutationsInBatch)(batch, clientTag);
+        }
+        next({
+          clientTag,
+          feedKey: mutation.meta.feedKey,
+          seq: mutation.meta.seq,
+          batch
+        });
+      });
+    });
+  }
+  async write(request) {
+    var _a, _b;
+    (0, import_node_assert.default)(this._writeStream, "Cannot write mutations in readonly mode");
+    (0, import_node_assert.default)(((_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
+var import_echo_db2 = require("@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 import_echo_db2.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
+var import_async = require("@dxos/async");
+var import_protocols = require("@dxos/protocols");
+var import_teleport_extension_object_sync = require("@dxos/teleport-extension-object-sync");
+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 SnapshotManager = class SnapshotManager2 {
+  // prettier-ignore
+  constructor(_snapshotStore) {
+    this._snapshotStore = _snapshotStore;
+    this._objectSync = new import_teleport_extension_object_sync.ObjectSync({
+      getObject: async (id) => {
+        const snapshot = await this._snapshotStore.loadSnapshot(id);
+        if (!snapshot) {
+          return void 0;
+        }
+        return {
+          id,
+          payload: import_protocols.schema.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").encodeAsAny(snapshot)
+        };
+      },
+      setObject: async (data) => {
+        const snapshot = import_protocols.schema.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 import_protocols.schema.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(remote.payload);
+  }
+  async store(snapshot) {
+    const id = await this._snapshotStore.saveSnapshot(snapshot);
+    return id;
+  }
+};
+SnapshotManager = __decorate([
+  (0, import_async.trackLeaks)("open", "close")
+], SnapshotManager);
+
+// packages/core/echo/echo-pipeline/src/dbhost/snapshot-store.ts
+var import_crypto = require("@dxos/crypto");
+var import_protocols2 = require("@dxos/protocols");
+var SnapshotStore = class {
+  // prettier-ignore
+  constructor(_directory) {
+    this._directory = _directory;
+  }
+  async saveSnapshot(snapshot) {
+    const encoded = import_protocols2.schema.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").encode(snapshot);
+    const key = await import_crypto.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 import_protocols2.schema.getCodecForType("dxos.echo.snapshot.SpaceSnapshot").decode(buffer);
+    } finally {
+      await file.close();
+    }
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/dbhost/data-service.ts
+var import_node_assert2 = __toESM(require("node:assert"));
+var import_debug = require("@dxos/debug");
+var import_keys = require("@dxos/keys");
+var import_log2 = require("@dxos/log");
+var import_util2 = require("@dxos/util");
+var DataServiceSubscriptions = class {
+  constructor() {
+    this._spaces = new import_util2.ComplexMap(import_keys.PublicKey.hash);
+  }
+  clear() {
+    this._spaces.clear();
+  }
+  registerSpace(spaceKey, host) {
+    (0, import_log2.log)("Registering space", {
+      spaceKey
+    }, {
+      file: "data-service.ts",
+      line: 31,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    this._spaces.set(spaceKey, host);
+  }
+  unregisterSpace(spaceKey) {
+    (0, import_log2.log)("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;
+    (0, import_node_assert2.default)(request.spaceKey);
+    const host = (_a = this._subscriptions.getDataService(request.spaceKey)) != null ? _a : (0, import_debug.raise)(new Error(`space not found: ${request.spaceKey}`));
+    return host.subscribe();
+  }
+  write(request) {
+    var _a;
+    (0, import_node_assert2.default)(request.spaceKey);
+    (0, import_node_assert2.default)(request.batch);
+    const host = (_a = this._subscriptions.getDataService(request.spaceKey)) != null ? _a : (0, import_debug.raise)(new Error(`space not found: ${request.spaceKey}`));
+    return host.write(request);
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/metadata/metadata-store.ts
+var import_node_assert3 = __toESM(require("node:assert"));
+var import_async2 = require("@dxos/async");
+var import_log3 = require("@dxos/log");
+var import_protocols3 = require("@dxos/protocols");
+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 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));
+      (0, import_log3.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 = import_protocols3.schema.getCodecForType("dxos.echo.metadata.EchoMetadata").decode(data);
+    } catch (err) {
+      import_log3.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(import_protocols3.schema.getCodecForType("dxos.echo.metadata.EchoMetadata").encode(data));
+      await file.write(0, toBytesInt32(encoded.length));
+      (0, import_log3.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() {
+    (0, import_log3.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) {
+    (0, import_node_assert3.default)(!this._metadata.identity, "Cannot overwrite existing identity in metadata");
+    this._metadata.identity = record;
+    await this._save();
+  }
+  async addSpace(record) {
+    var _a, _b, _c;
+    (0, import_node_assert3.default)(!((_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);
+    (0, import_node_assert3.default)(space, "Space not found");
+    space.dataTimeframe = timeframe;
+    await this._save();
+  }
+  async setSpaceSnapshot(spaceKey, snapshot) {
+    const space = this.spaces.find((space2) => space2.key === spaceKey);
+    (0, import_node_assert3.default)(space, "Space not found");
+    space.snapshot = snapshot;
+    await this._save();
+  }
+  async setWritableFeedKeys(spaceKey, controlFeedKey, dataFeedKey) {
+    const space = this.spaces.find((space2) => space2.key === spaceKey);
+    (0, import_node_assert3.default)(space, "Space not found");
+    space.controlFeedKey = controlFeedKey;
+    space.dataFeedKey = dataFeedKey;
+    await this._save();
+  }
+};
+__decorate2([
+  import_async2.synchronized
+], MetadataStore.prototype, "load", null);
+__decorate2([
+  import_async2.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/space/auth.ts
+var import_node_assert4 = __toESM(require("node:assert"));
+var import_async3 = require("@dxos/async");
+var import_context = require("@dxos/context");
+var import_crypto2 = require("@dxos/crypto");
+var import_log4 = require("@dxos/log");
+var import_protocols4 = require("@dxos/protocols");
+var import_teleport = require("@dxos/teleport");
+var AuthExtension = class extends import_teleport.RpcExtension {
+  constructor(_authParams) {
+    super({
+      requested: {
+        AuthService: import_protocols4.schema.getService("dxos.mesh.teleport.auth.AuthService")
+      },
+      exposed: {
+        AuthService: import_protocols4.schema.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 import_context.Context({
+      onError: (err) => {
+        import_log4.log.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) {
+            import_log4.log.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);
+    (0, import_async3.scheduleTask)(this._ctx, async () => {
+      try {
+        const challenge = (0, import_crypto2.randomBytes)(32);
+        const { credential } = await this.rpc.AuthService.authenticate({
+          challenge
+        });
+        (0, import_node_assert4.default)((credential == null ? void 0 : credential.length) > 0, "invalid credential");
+        const success = await this._authParams.verifier(challenge, credential);
+        (0, import_node_assert4.default)(success, "credential not verified");
+        (0, import_async3.runInContext)(this._ctx, () => this._authParams.onAuthSuccess());
+      } catch (err) {
+        import_log4.log.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
+var import_node_assert8 = __toESM(require("node:assert"));
+var import_async6 = require("@dxos/async");
+var import_log8 = require("@dxos/log");
+var import_credentials3 = require("@dxos/protocols/proto/dxos/halo/credentials");
+var import_util4 = require("@dxos/util");
+
+// packages/core/echo/echo-pipeline/src/pipeline/pipeline.ts
+var import_node_assert7 = __toESM(require("node:assert"));
+var import_async5 = require("@dxos/async");
+var import_feed_store = require("@dxos/feed-store");
+var import_keys2 = require("@dxos/keys");
+var import_log6 = require("@dxos/log");
+var import_timeframe2 = require("@dxos/timeframe");
+
+// packages/core/echo/echo-pipeline/src/common/codec.ts
+var import_hypercore = require("@dxos/hypercore");
+var import_protocols5 = require("@dxos/protocols");
+var codec = import_protocols5.schema.getCodecForType("dxos.echo.feed.FeedMessage");
+var valueEncoding = (0, import_hypercore.createCodecEncoding)(codec);
+
+// packages/core/echo/echo-pipeline/src/common/feeds.ts
+var import_node_assert5 = __toESM(require("node:assert"));
+var createMappedFeedWriter = (mapper, writer) => {
+  (0, import_node_assert5.default)(mapper);
+  (0, import_node_assert5.default)(writer);
+  return {
+    write: async (data) => await writer.write(await mapper(data))
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/pipeline/message-selector.ts
+var import_debug2 = __toESM(require("debug"));
+var import_node_assert6 = __toESM(require("node:assert"));
+var log5 = (0, import_debug2.default)("dxos:echo-db:message-selector");
+var createMessageSelector = (timeframeClock) => {
+  return (messages) => {
+    for (let i = 0; i < messages.length; i++) {
+      const { data: { timeframe } } = messages[i];
+      (0, import_node_assert6.default)(timeframe);
+      if (!timeframeClock.hasGaps(timeframe)) {
+        return i;
+      }
+    }
+    log5("Skipping...");
+  };
+};
+
+// packages/core/echo/echo-pipeline/src/pipeline/timeframe-clock.ts
+var import_async4 = require("@dxos/async");
+var import_debug3 = require("@dxos/debug");
+var import_log5 = require("@dxos/log");
+var import_timeframe = require("@dxos/timeframe");
+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 mapTimeframeToFeedIndexes = (timeframe) => timeframe.frames().map(([feedKey, index]) => ({
+  feedKey,
+  index
+}));
+var mapFeedIndexesToTimeframe = (indexes) => new import_timeframe.Timeframe(indexes.map(({ feedKey, index }) => [
+  feedKey,
+  index
+]));
+var TimeframeClock = class {
+  // prettier-ignore
+  constructor(_timeframe = new import_timeframe.Timeframe()) {
+    this._timeframe = _timeframe;
+    this.update = new import_async4.Event();
+  }
+  get timeframe() {
+    return this._timeframe;
+  }
+  updateTimeframe(key, seq) {
+    this._timeframe = import_timeframe.Timeframe.merge(this._timeframe, new import_timeframe.Timeframe([
+      [
+        key,
+        seq
+      ]
+    ]));
+    this.update.emit(this._timeframe);
+  }
+  hasGaps(timeframe) {
+    const gaps = import_timeframe.Timeframe.dependencies(timeframe, this._timeframe);
+    return !gaps.isEmpty();
+  }
+  async waitUntilReached(target) {
+    import_log5.log.debug("waitUntilReached", {
+      target,
+      current: this._timeframe
+    }, {
+      file: "timeframe-clock.ts",
+      line: 45,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this.update.waitForCondition(() => {
+      (0, import_log5.log)("check if reached", {
+        target,
+        current: this._timeframe,
+        deps: import_timeframe.Timeframe.dependencies(target, this._timeframe)
+      }, {
+        file: "timeframe-clock.ts",
+        line: 47,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      return import_timeframe.Timeframe.dependencies(target, this._timeframe).isEmpty();
+    });
+  }
+};
+__decorate3([
+  (0, import_debug3.timed)(5e3)
+], TimeframeClock.prototype, "waitUntilReached", null);
+
+// 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 ? import_timeframe2.Timeframe.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;
+    (0, import_log6.log)("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 import_timeframe2.Timeframe.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;
+        }),
+        (0, import_async5.sleep)(timeout).then(() => {
+          if (done) {
+            return;
+          }
+          import_log6.log.warn("waitUntilReachedTargetTimeframe timed out", {
+            timeout,
+            current: this.timeframe,
+            target: this.targetTimeframe,
+            dependencies: import_timeframe2.Timeframe.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 import_timeframe2.Timeframe()) {
+    this._initialTimeframe = _initialTimeframe;
+    this._timeframeClock = new TimeframeClock(this._initialTimeframe);
+    this._feedSetIterator = new import_feed_store.FeedSetIterator(createMessageSelector(this._timeframeClock), {
+      start: mapTimeframeToFeedIndexes(this._initialTimeframe),
+      stallTimeout: 1e3
+    });
+    this._state = new PipelineState(this._feedSetIterator, this._timeframeClock);
+    this._processingTrigger = new import_async5.Trigger().wake();
+    this._isOpen = false;
+    this._feedSetIterator.stalled.on((iterator) => {
+      import_log6.log.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() {
+    (0, import_node_assert7.default)(this._writer, "Writer not set.");
+    return this._writer;
+  }
+  getFeeds() {
+    return this._feedSetIterator.feeds;
+  }
+  async addFeed(feed) {
+    await this._feedSetIterator.addFeed(feed);
+  }
+  setWriteFeed(feed) {
+    (0, import_node_assert7.default)(!this._writer, "Writer already set.");
+    (0, import_node_assert7.default)(feed.properties.writable, "Feed must be writable.");
+    this._writer = createMappedFeedWriter((payload) => ({
+      timeframe: this._timeframeClock.timeframe,
+      payload
+    }), feed.createFeedWriter());
+  }
+  async start() {
+    (0, import_log6.log)("starting...", {}, {
+      file: "pipeline.ts",
+      line: 218,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._feedSetIterator.open();
+    (0, import_log6.log)("started", {}, {
+      file: "pipeline.ts",
+      line: 220,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    (0, import_log6.log)("stopping...", {}, {
+      file: "pipeline.ts",
+      line: 224,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._feedSetIterator.close();
+    await this._processingTrigger.wait();
+    (0, import_log6.log)("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() {
+    (0, import_node_assert7.default)(!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(import_keys2.PublicKey.from(block.feedKey), block.seq);
+    }
+    this._isOpen = false;
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/space/control-pipeline.ts
+var import_credentials = require("@dxos/credentials");
+var import_keys3 = require("@dxos/keys");
+var import_log7 = require("@dxos/log");
+var import_credentials2 = require("@dxos/protocols/proto/dxos/halo/credentials");
+var import_util3 = require("@dxos/util");
+var ControlPipeline = class {
+  constructor({ spaceKey, genesisFeed, feedProvider, initialTimeframe }) {
+    this.onFeedAdmitted = new import_util3.Callback();
+    this._pipeline = new Pipeline(initialTimeframe);
+    void this._pipeline.addFeed(genesisFeed);
+    this._spaceStateMachine = new import_credentials.SpaceStateMachine(spaceKey);
+    this._spaceStateMachine.onFeedAdmitted.set(async (info) => {
+      (0, import_log7.log)("feed admitted", {
+        key: info.key
+      }, {
+        file: "control-pipeline.ts",
+        line: 41,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      if (info.assertion.designation === import_credentials2.AdmittedFeed.Designation.CONTROL && !info.key.equals(genesisFeed.key)) {
+        try {
+          const feed = await feedProvider(info.key);
+          await this._pipeline.addFeed(feed);
+        } catch (err) {
+          import_log7.log.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() {
+    (0, import_log7.log)("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 {
+          (0, import_log7.log)("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, import_keys3.PublicKey.from(msg.feedKey));
+            if (!result) {
+              import_log7.log.warn("processing failed", {
+                msg
+              }, {
+                file: "control-pipeline.ts",
+                line: 85,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+            }
+          }
+        } catch (err) {
+          import_log7.log.catch(err, {}, {
+            file: "control-pipeline.ts",
+            line: 89,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    await this._pipeline.start();
+    (0, import_log7.log)("started", {}, {
+      file: "control-pipeline.ts",
+      line: 95,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    (0, import_log7.log)("stopping...", {}, {
+      file: "control-pipeline.ts",
+      line: 99,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._pipeline.stop();
+    (0, import_log7.log)("stopped", {}, {
+      file: "control-pipeline.ts",
+      line: 101,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+};
+
+// 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;
+  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 import_util4.Callback();
+    this.stateUpdate = new import_async6.Event();
+    this._isOpen = false;
+    (0, import_node_assert8.default)(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 === import_credentials3.AdmittedFeed.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);
+      (0, import_log8.log)("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) {
+    (0, import_node_assert8.default)(!this._controlFeed, "Control feed already set.");
+    this._controlFeed = feed;
+    this._controlPipeline.setWriteFeed(feed);
+    return this;
+  }
+  setDataFeed(feed) {
+    var _a;
+    (0, import_node_assert8.default)(!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() {
+    (0, import_log8.log)("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;
+    (0, import_log8.log)("opened", {}, {
+      file: "space.ts",
+      line: 155,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async close() {
+    var _a;
+    (0, import_log8.log)("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;
+    (0, import_log8.log)("closed", {}, {
+      file: "space.ts",
+      line: 171,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async initDataPipeline(controller) {
+    (0, import_node_assert8.default)(this._isOpen, "Space must be open to initialize data pipeline.");
+    (0, import_node_assert8.default)(!this._dataPipelineController, "Data pipeline already initialized.");
+    (0, import_node_assert8.default)(!this._dataPipeline, "Data pipeline already initialized.");
+    this._dataPipelineController = controller;
+    await this._dataPipelineController.open({
+      openPipeline: async (start) => {
+        (0, import_node_assert8.default)(!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 === import_credentials3.AdmittedFeed.Designation.DATA) {
+            await this._dataPipeline.addFeed(await this._feedProvider(feed.key));
+          }
+        }
+        await this._dataPipeline.start();
+        return this._dataPipeline;
+      }
+    });
+  }
+};
+__decorate4([
+  import_log8.logInfo
+], Space.prototype, "key", null);
+__decorate4([
+  import_async6.synchronized
+], Space.prototype, "open", null);
+__decorate4([
+  import_async6.synchronized
+], Space.prototype, "close", null);
+Space = __decorate4([
+  (0, import_async6.trackLeaks)("open", "close")
+], Space);
+
+// packages/core/echo/echo-pipeline/src/space/space-manager.ts
+var import_async7 = require("@dxos/async");
+var import_debug4 = require("@dxos/debug");
+var import_keys5 = require("@dxos/keys");
+var import_log10 = require("@dxos/log");
+var import_util6 = require("@dxos/util");
+
+// packages/core/echo/echo-pipeline/src/space/space-protocol.ts
+var import_crypto3 = require("@dxos/crypto");
+var import_keys4 = require("@dxos/keys");
+var import_log9 = require("@dxos/log");
+var import_network_manager = require("@dxos/network-manager");
+var import_teleport2 = require("@dxos/teleport");
+var import_teleport_extension_replicator = require("@dxos/teleport-extension-replicator");
+var import_util5 = require("@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 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 import_util5.ComplexMap(import_keys4.PublicKey.hash);
+    this._networkManager = networkManager;
+    this._swarmIdentity = swarmIdentity;
+    this._onSessionAuth = onSessionAuth;
+    this._topic = import_keys4.PublicKey.from((0, import_crypto3.discoveryKey)((0, import_crypto3.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) {
+    (0, import_log9.log)("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
+    };
+    (0, import_log9.log)("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 import_network_manager.MMSTTopology(topologyConfig),
+      label: `Protocol swarm: ${this._topic}`
+    });
+    (0, import_log9.log)("started", {}, {
+      file: "space-protocol.ts",
+      line: 116,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    if (this._connection) {
+      (0, import_log9.log)("stopping...", {}, {
+        file: "space-protocol.ts",
+        line: 121,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      await this._connection.close();
+      (0, import_log9.log)("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;
+    };
+  }
+};
+__decorate5([
+  import_log9.logInfo
+], SpaceProtocol.prototype, "_topic", void 0);
+__decorate5([
+  import_log9.logInfo
+], 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 import_teleport_extension_replicator.ReplicatorExtension().setOptions({
+      upload: true
+    });
+    this._authStatus = AuthStatus.INITIAL;
+    this._wireParams = wireParams;
+    this._swarmIdentity = swarmIdentity;
+    this._onSessionAuth = onSessionAuth;
+    this._teleport = new import_teleport2.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;
+        (0, import_log9.log)("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: () => {
+        import_log9.log.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();
+  }
+};
+__decorate5([
+  import_log9.logInfo
+], SpaceProtocolSession.prototype, "_wireParams", void 0);
+__decorate5([
+  import_log9.logInfo
+], SpaceProtocolSession.prototype, "authStatus", null);
+
+// packages/core/echo/echo-pipeline/src/space/space-manager.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 SpaceManager = class SpaceManager2 {
+  constructor({ feedStore, networkManager }) {
+    this._spaces = new import_util6.ComplexMap(import_keys5.PublicKey.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;
+    (0, import_log10.log)("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 : (0, import_debug4.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;
+  }
+};
+__decorate6([
+  import_async7.synchronized
+], SpaceManager.prototype, "open", null);
+__decorate6([
+  import_async7.synchronized
+], SpaceManager.prototype, "close", null);
+SpaceManager = __decorate6([
+  (0, import_async7.trackLeaks)("open", "close")
+], SpaceManager);
+
+// packages/core/echo/echo-pipeline/src/space/genesis.ts
+var import_credentials4 = require("@dxos/credentials");
+var import_debug5 = require("@dxos/debug");
+var import_credentials5 = require("@dxos/protocols/proto/dxos/halo/credentials");
+
+// packages/core/echo/echo-pipeline/src/space/data-pipeline-controller.ts
+var import_node_assert9 = __toESM(require("node:assert"));
+var import_async8 = require("@dxos/async");
+var import_context2 = require("@dxos/context");
+var import_debug6 = require("@dxos/debug");
+var import_echo_db3 = require("@dxos/echo-db");
+var import_log11 = require("@dxos/log");
+var import_timeframe3 = require("@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 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 import_context2.Context();
+    this._lastAutomaticSnapshotTimeframe = new import_timeframe3.Timeframe();
+    this.onTimeframeReached = new import_async8.Event();
+  }
+  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 import_timeframe3.Timeframe());
+  }
+  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 import_timeframe3.Timeframe();
+    }
+    this._pipeline = await this._spaceContext.openPipeline(this.getStartTimeframe());
+    const feedWriter = createMappedFeedWriter((data) => ({
+      data
+    }), (_c = this._pipeline.writer) != null ? _c : (0, import_debug6.failUndefined)());
+    this.databaseBackend = new DatabaseBackendHost(feedWriter, (_d = this._snapshot) == null ? void 0 : _d.database, {
+      snapshots: true
+      // TODO(burdon): Config.
+    });
+    this._itemManager = new import_echo_db3.ItemManager(this._params.modelFactory);
+    await this.databaseBackend.open(this._itemManager, this._params.modelFactory);
+    (0, import_async8.scheduleTask)(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 : (0, import_debug6.failUndefined)();
+        (0, import_log11.log)("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) {
+      import_log11.log.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 import_timeframe3.Timeframe(),
+      database: this.databaseBackend.createSnapshot()
+    };
+  }
+  async _consumePipeline() {
+    (0, import_node_assert9.default)(this._pipeline, "Pipeline is not initialized.");
+    for await (const msg of this._pipeline.consume()) {
+      const { feedKey, seq, data } = msg;
+      (0, import_log11.log)("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) {
+            import_log11.log.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) {
+        import_log11.log.catch(err, {}, {
+          file: "data-pipeline-controller.ts",
+          line: 218,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+      }
+    }
+  }
+  async waitUntilTimeframe(timeframe) {
+    (0, import_node_assert9.default)(this._pipeline, "Pipeline is not initialized.");
+    await this._pipeline.state.waitUntilTimeframe(timeframe);
+  }
+};
+DataPipelineControllerImpl = __decorate7([
+  (0, import_async8.trackLeaks)("open", "close")
+], DataPipelineControllerImpl);
+var snapshotTimeframeToStartingTimeframe = (snapshotTimeframe) => {
+  return snapshotTimeframe.map(([key, seq]) => [
+    key,
+    seq + 1
+  ]);
+};
+
+// packages/core/echo/echo-pipeline/src/testing/test-feed-builder.ts
+var import_testing = require("@dxos/feed-store/testing");
+var TestFeedBuilder = class extends import_testing.TestBuilder {
+  constructor() {
+    super({
+      valueEncoding
+    });
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/testing/test-agent-builder.ts
+var MemoryNetworkManagerProvider = (signalContext) => () => new import_network_manager2.NetworkManager({
+  signalManager: new import_messaging.MemorySignalManager(signalContext),
+  transportFactory: import_network_manager2.MemoryTransportFactory
+});
+var WebsocketNetworkManagerProvider = (signalUrl) => () => new import_network_manager2.NetworkManager({
+  signalManager: new import_messaging.WebsocketSignalManager([
+    signalUrl
+  ]),
+  transportFactory: (0, import_network_manager2.createWebRTCTransportFactory)()
+});
+var TestAgentBuilder = class {
+  constructor({ storage, networkManagerProvider } = {}) {
+    this._agents = new import_util7.ComplexMap(import_keys6.PublicKey.hash);
+    this._storage = storage != null ? storage : (0, import_random_access_storage.createStorage)({
+      type: import_random_access_storage.StorageType.RAM
+    });
+    this._networkManagerProvider = networkManagerProvider != null ? networkManagerProvider : MemoryNetworkManagerProvider(new import_messaging.MemorySignalManagerContext());
+  }
+  async close() {
+    return Promise.all(this.agents.map((agent) => agent.close()));
+  }
+  get agents() {
+    return Array.from(this._agents.values());
+  }
+  getAgent(deviceKey) {
+    return this._agents.get(deviceKey);
+  }
+  async createPeer() {
+    const feedBuilder = new TestFeedBuilder().setStorage(this._storage, `agent-${this._agents.size}`);
+    const identityKey = await feedBuilder.keyring.createKey();
+    const deviceKey = await feedBuilder.keyring.createKey();
+    const agent = new TestAgent(this._networkManagerProvider, feedBuilder, identityKey, deviceKey);
+    this._agents.set(deviceKey, agent);
+    return agent;
+  }
+};
+var TestAgent = class {
+  constructor(_networkManagerProvider, _feedBuilder, identityKey, deviceKey) {
+    this._networkManagerProvider = _networkManagerProvider;
+    this._feedBuilder = _feedBuilder;
+    this.identityKey = identityKey;
+    this.deviceKey = deviceKey;
+    this._spaces = new import_util7.ComplexMap(import_keys6.PublicKey.hash);
+    this.keyring = this._feedBuilder.keyring;
+    this.feedStore = this._feedBuilder.createFeedStore();
+  }
+  async close() {
+    return Promise.all([
+      ...this.spaces.map((space) => space.close())
+    ]);
+  }
+  get spaces() {
+    return Array.from(this._spaces.values());
+  }
+  getSpace(spaceKey) {
+    return this._spaces.get(spaceKey);
+  }
+  createSpaceManager() {
+    return new SpaceManager({
+      feedStore: this._feedBuilder.createFeedStore(),
+      networkManager: this._networkManagerProvider()
+    });
+  }
+  async createSpace(identityKey = this.identityKey, spaceKey, genesisKey) {
+    if (!spaceKey) {
+      spaceKey = await this.keyring.createKey();
+    }
+    const dataFeedKey = await this.keyring.createKey();
+    const dataFeed = await this.feedStore.openFeed(dataFeedKey, {
+      writable: true
+    });
+    const controlFeedKey = await this.keyring.createKey();
+    const controlFeed = await this.feedStore.openFeed(controlFeedKey, {
+      writable: true
+    });
+    const genesisFeed = genesisKey ? await this.feedStore.openFeed(genesisKey) : controlFeed;
+    const snapshotManager = new SnapshotManager(new SnapshotStore((0, import_random_access_storage.createStorage)().createDirectory("snapshots")));
+    const metadataStore = new MetadataStore((0, import_random_access_storage.createStorage)().createDirectory("metadata"));
+    await metadataStore.addSpace({
+      key: spaceKey
+    });
+    const dataPipelineController = new DataPipelineControllerImpl({
+      modelFactory: new import_model_factory.ModelFactory().registerModel(import_document_model.DocumentModel),
+      metadataStore,
+      snapshotManager,
+      memberKey: identityKey,
+      spaceKey,
+      feedInfoProvider: (feedKey) => space.spaceState.feeds.get(feedKey),
+      snapshotId: void 0
+    });
+    const space = new Space({
+      spaceKey,
+      protocol: this.createSpaceProtocol(spaceKey),
+      genesisFeed,
+      feedProvider: (feedKey) => this.feedStore.openFeed(feedKey)
+    }).setControlFeed(controlFeed).setDataFeed(dataFeed);
+    await space.open();
+    await space.initDataPipeline(dataPipelineController);
+    this._spaces.set(spaceKey, space);
+    return [
+      space,
+      dataPipelineController
+    ];
+  }
+  createSpaceProtocol(topic, presence) {
+    return new SpaceProtocol({
+      topic,
+      swarmIdentity: {
+        peerKey: this.deviceKey,
+        credentialProvider: MOCK_AUTH_PROVIDER,
+        credentialAuthenticator: MOCK_AUTH_VERIFIER
+      },
+      networkManager: this._networkManagerProvider(),
+      onSessionAuth: (session) => {
+        session.addExtension("dxos.mesh.teleport.presence", (presence != null ? presence : this.createPresence()).createExtension({
+          remotePeerId: session.remotePeerId
+        }));
+      }
+    });
+  }
+  createPresence() {
+    return new import_teleport_extension_presence.Presence({
+      localPeerId: this.deviceKey,
+      announceInterval: 30,
+      offlineTimeout: 200,
+      identityKey: this.identityKey
+    });
+  }
+};
+
+// packages/core/echo/echo-pipeline/src/testing/util.ts
+var import_async9 = require("@dxos/async");
+var import_document_model2 = require("@dxos/document-model");
+var import_echo_db4 = require("@dxos/echo-db");
+var import_testing2 = require("@dxos/feed-store/testing");
+var import_keys7 = require("@dxos/keys");
+var import_model_factory2 = require("@dxos/model-factory");
+var import_timeframe4 = require("@dxos/timeframe");
+var createMemoryDatabase = async (modelFactory) => {
+  const feed = new import_testing2.MockFeedWriter();
+  const backend = new DatabaseBackendHost(feed, void 0, {
+    snapshots: true
+  });
+  feed.written.on(([data, meta]) => backend.echoProcessor({
+    data: data.object,
+    meta: {
+      ...meta,
+      memberKey: import_keys7.PublicKey.random(),
+      timeframe: new import_timeframe4.Timeframe([
+        [
+          meta.feedKey,
+          meta.seq
+        ]
+      ])
+    }
+  }));
+  const itemManager = new import_echo_db4.ItemManager(modelFactory);
+  await backend.open(itemManager, new import_model_factory2.ModelFactory().registerModel(import_document_model2.DocumentModel));
+  return {
+    backend,
+    itemManager
+  };
+};
+var createRemoteDatabaseFromDataServiceHost = async (modelFactory, dataServiceHost) => {
+  const dataServiceSubscriptions = new DataServiceSubscriptions();
+  const dataService = new DataServiceImpl(dataServiceSubscriptions);
+  const spaceKey = import_keys7.PublicKey.random();
+  dataServiceSubscriptions.registerSpace(spaceKey, dataServiceHost);
+  const backend = new import_echo_db4.DatabaseBackendProxy(dataService, spaceKey);
+  const itemManager = new import_echo_db4.ItemManager(modelFactory);
+  await backend.open(itemManager, new import_model_factory2.ModelFactory().registerModel(import_document_model2.DocumentModel));
+  return {
+    itemManager,
+    backend
+  };
+};
+var testLocalDatabase = async (create, check = create) => {
+  var _a;
+  const objectId = import_keys7.PublicKey.random().toHex();
+  await ((_a = create.databaseBackend.getWriteStream()) == null ? void 0 : _a.write({
+    object: {
+      objectId,
+      genesis: {
+        modelType: import_document_model2.DocumentModel.meta.type
+      }
+    }
+  }));
+  await (0, import_async9.asyncTimeout)(check._itemManager.update.waitForCondition(() => check._itemManager.entities.has(objectId)), 500);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryNetworkManagerProvider,
+  TestAgent,
+  TestAgentBuilder,
+  TestFeedBuilder,
+  WebsocketNetworkManagerProvider,
+  createMemoryDatabase,
+  createRemoteDatabaseFromDataServiceHost,
+  testLocalDatabase
+});
+//# sourceMappingURL=index.cjs.map