@dxos/client-services 0.1.13 → 0.1.16

package/dist/lib/browser/index.mjs

@@ -0,0 +1,2749 @@
+import "@dxos/node-std/globals"
+
+// packages/sdk/client-services/src/packlets/deprecated/space.ts
+import assert from "@dxos/node-std/assert";
+import { EventSubscriptions } from "@dxos/async";
+import { Stream } from "@dxos/codec-protobuf";
+import { todo } from "@dxos/debug";
+import { log } from "@dxos/log";
+import { humanize } from "@dxos/util";
+var SpaceServiceImpl = class {
+  constructor(serviceContext) {
+    this.serviceContext = serviceContext;
+    this.inviteeInvitations = /* @__PURE__ */ new Map();
+  }
+  subscribeToSpace(request) {
+    return new Stream(({ next }) => {
+      next({
+        space: {
+          publicKey: request.spaceKey,
+          isOpen: true,
+          isActive: true,
+          members: []
+        }
+      });
+    });
+  }
+  subscribeSpaces() {
+    return new Stream(({ next }) => {
+      const subscriptions = new EventSubscriptions();
+      const onUpdate = () => {
+        const spaces = Array.from(this.serviceContext.spaceManager.spaces.values()).map((space) => ({
+          publicKey: space.key,
+          isOpen: true,
+          isActive: true,
+          members: Array.from(space.spaceState.members.values()).map((member) => {
+            var _a, _b;
+            return {
+              identityKey: member.key,
+              profile: {
+                identityKey: member.key,
+                displayName: (_b = (_a = member.assertion.profile) == null ? void 0 : _a.displayName) != null ? _b : humanize(member.key)
+              }
+            };
+          })
+        }));
+        log("update", {
+          spaces
+        }, {
+          file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/deprecated/space.ts",
+          line: 114,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        next({
+          spaces
+        });
+      };
+      setTimeout(async () => {
+        if (!this.serviceContext.spaceManager) {
+          next({
+            spaces: []
+          });
+        }
+        await this.serviceContext.initialized.wait();
+        subscriptions.add(this.serviceContext.spaceManager.updated.on(() => {
+          this.serviceContext.spaceManager.spaces.forEach((space) => {
+            subscriptions.add(space.stateUpdate.on(onUpdate));
+          });
+          onUpdate();
+        }));
+        this.serviceContext.spaceManager.spaces.forEach((space) => {
+          subscriptions.add(space.stateUpdate.on(onUpdate));
+        });
+        onUpdate();
+      });
+      return () => subscriptions.clear();
+    });
+  }
+  async getSpaceDetails(request) {
+    return todo();
+  }
+  async createSpace() {
+    await this.serviceContext.initialized.wait();
+    const space = await this.serviceContext.spaceManager.createSpace();
+    return {
+      publicKey: space.key,
+      isOpen: true,
+      isActive: true
+    };
+  }
+  async cloneSpace(snapshot) {
+    return todo();
+  }
+  async setSpaceState(request) {
+    return todo();
+  }
+  async authenticateInvitation(request) {
+    var _a;
+    assert(request.processId, "Process ID is missing.");
+    const invitation = this.inviteeInvitations.get(request.processId);
+    assert(invitation, "Invitation not found.");
+    assert(request.secret, "Secret not provided.");
+    invitation.secret = request.secret;
+    (_a = invitation.secretTrigger) == null ? void 0 : _a.call(invitation);
+  }
+  subscribeMembers(request) {
+    return todo();
+  }
+  async createSnapshot(request) {
+    return todo();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/deprecated/profile.ts
+import { Stream as Stream2 } from "@dxos/codec-protobuf";
+import { todo as todo2 } from "@dxos/debug";
+var ProfileServiceImpl = class {
+  constructor(context) {
+    this.context = context;
+    this.inviteeInvitations = /* @__PURE__ */ new Map();
+  }
+  subscribeProfile() {
+    return new Stream2(({ next }) => {
+      const emitNext = () => {
+        var _a;
+        return next({
+          profile: this.context.identityManager.identity ? {
+            identityKey: this.context.identityManager.identity.identityKey,
+            deviceKey: this.context.identityManager.identity.deviceKey,
+            displayName: (_a = this.context.identityManager.identity.profileDocument) == null ? void 0 : _a.displayName
+          } : void 0
+        });
+      };
+      emitNext();
+      return this.context.identityManager.stateUpdate.on(emitNext);
+    });
+  }
+  async createProfile(request) {
+    var _a;
+    await this.context.createIdentity({
+      displayName: request.displayName
+    });
+    return {
+      identityKey: this.context.identityManager.identity.identityKey,
+      deviceKey: this.context.identityManager.identity.deviceKey,
+      displayName: (_a = this.context.identityManager.identity.profileDocument) == null ? void 0 : _a.displayName
+    };
+  }
+  async recoverProfile(request) {
+    return todo2();
+    if (!request.seedPhrase) {
+      throw new Error("Recovery SeedPhrase not provided.");
+    }
+  }
+};
+
+// packages/sdk/client-services/src/packlets/deprecated/system.ts
+var SystemServiceImpl = class {
+  constructor(_config, _serviceContext) {
+    this._config = _config;
+    this._serviceContext = _serviceContext;
+  }
+  async initSession() {
+  }
+  async getConfig(request) {
+    return this._config.values;
+  }
+  async getStatus(request) {
+    return {
+      message: `ok: ${Date.now()}`
+    };
+  }
+  async reset(request) {
+    await this._serviceContext.reset();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/deprecated/tracing.ts
+var TracingServiceImpl = class {
+  constructor(_config) {
+    this._config = _config;
+  }
+  async setTracingOptions() {
+    throw new Error("Tracing not available.");
+  }
+  subscribeToRpcTrace() {
+    throw new Error("Tracing not available.");
+  }
+};
+
+// packages/sdk/client-services/src/packlets/devtools/devtools.ts
+import { Event as AsyncEvent } from "@dxos/async";
+import { Stream as Stream7 } from "@dxos/codec-protobuf";
+
+// packages/sdk/client-services/src/packlets/devtools/feeds.ts
+import { EventSubscriptions as EventSubscriptions2 } from "@dxos/async";
+import { Stream as Stream3 } from "@dxos/codec-protobuf";
+import { FeedIterator } from "@dxos/feed-store";
+import { PublicKey } from "@dxos/keys";
+import { ComplexMap } from "@dxos/util";
+var subscribeToFeeds = ({ feedStore }, { feedKeys }) => new Stream3(({ next }) => {
+  if ((feedKeys == null ? void 0 : feedKeys.length) === 0) {
+    return;
+  }
+  const feedMap = new ComplexMap(PublicKey.hash);
+  const subscriptions = new EventSubscriptions2();
+  const update = () => {
+    const feeds = feedStore.feeds;
+    feeds.filter((feed) => !(feedKeys == null ? void 0 : feedKeys.length) || feedKeys.some((feedKey) => feedKey.equals(feed.key))).forEach((feed) => {
+      if (!feedMap.has(feed.key)) {
+        feedMap.set(feed.key, feed);
+        feed.on("close", update);
+        subscriptions.add(feed.off("close", update));
+      }
+    });
+    next({
+      feeds: Array.from(feedMap.values()).map((feed) => ({
+        feedKey: feed.key,
+        length: feed.properties.length
+      }))
+    });
+  };
+  subscriptions.add(feedStore.feedOpened.on(update));
+  update();
+  return () => {
+    subscriptions.clear();
+  };
+});
+var subscribeToFeedBlocks = ({ feedStore }, { feedKey, maxBlocks = 10 }) => new Stream3(({ next }) => {
+  if (!feedKey) {
+    return;
+  }
+  const subscriptions = new EventSubscriptions2();
+  const timeout = setTimeout(async () => {
+    const feed = feedStore.getFeed(feedKey);
+    if (!feed) {
+      return;
+    }
+    const update = async () => {
+      const iterator = new FeedIterator(feed);
+      await iterator.open();
+      const blocks = [];
+      for await (const block of iterator) {
+        blocks.push(block);
+        if (blocks.length >= feed.properties.length) {
+          break;
+        }
+      }
+      next({
+        blocks: blocks.slice(-maxBlocks)
+      });
+      await iterator.close();
+    };
+    feed.on("append", update);
+    subscriptions.add(() => feed.off("append", update));
+    feed.on("truncate", update);
+    subscriptions.add(() => feed.off("truncate", update));
+    await update();
+  });
+  return () => {
+    subscriptions.clear();
+    clearTimeout(timeout);
+  };
+});
+
+// packages/sdk/client-services/src/packlets/devtools/keys.ts
+import { Stream as Stream4 } from "@dxos/codec-protobuf";
+var subscribeToKeyringKeys = ({ keyring }) => new Stream4(({ next }) => {
+  const update = () => {
+    next({
+      keys: keyring.list()
+    });
+  };
+  const unsubscribe = keyring.keysUpdate.on(update);
+  update();
+  return unsubscribe;
+});
+
+// packages/sdk/client-services/src/packlets/devtools/network.ts
+import { Stream as Stream5 } from "@dxos/codec-protobuf";
+import { PublicKey as PublicKey2 } from "@dxos/keys";
+var subscribeToNetworkStatus = ({ networkManager }) => new Stream5(({ next, close }) => {
+  const update = () => {
+    try {
+      const status = networkManager.signalManager.getStatus();
+      next({
+        servers: status
+      });
+    } catch (err) {
+      close(err);
+    }
+  };
+  networkManager.signalManager.statusChanged.on(update);
+  update();
+});
+var subscribeToSignalTrace = ({ networkManager }) => new Stream5(({ next }) => {
+  next({
+    events: []
+  });
+  const trace = [];
+  networkManager.signalManager.commandTrace.on((msg) => {
+    trace.push(msg);
+    next({
+      events: trace.map((msg2) => JSON.stringify(msg2))
+    });
+  });
+});
+var subscribeToNetworkTopics = ({ networkManager }) => new Stream5(({ next, close }) => {
+  const update = () => {
+    try {
+      const topics = networkManager.topics;
+      const labeledTopics = topics.map((topic) => {
+        var _a, _b;
+        return {
+          topic,
+          label: (_b = (_a = networkManager.getSwarm(topic)) == null ? void 0 : _a.label) != null ? _b : topic.toHex()
+        };
+      });
+      next({
+        topics: labeledTopics
+      });
+    } catch (err) {
+      close(err);
+    }
+  };
+  networkManager.topicsUpdated.on(update);
+  update();
+});
+var subscribeToSwarmInfo = ({ networkManager }) => new Stream5(({ next }) => {
+  var _a;
+  const update = () => {
+    var _a2;
+    const info = (_a2 = networkManager.connectionLog) == null ? void 0 : _a2.swarms;
+    if (info) {
+      next({
+        data: info
+      });
+    }
+  };
+  (_a = networkManager.connectionLog) == null ? void 0 : _a.update.on(update);
+  update();
+});
+var getNetworkPeers = ({ networkManager }, request) => {
+  if (!request.topic) {
+    throw new Error("Expected a network topic");
+  }
+  const map = networkManager.getSwarmMap(PublicKey2.from(request.topic));
+  return {
+    peers: map == null ? void 0 : map.peers.map((peer) => ({
+      ...peer,
+      connections: peer.connections.map((connection) => connection.asUint8Array())
+    }))
+  };
+};
+
+// packages/sdk/client-services/src/packlets/devtools/spaces.ts
+import { Stream as Stream6 } from "@dxos/codec-protobuf";
+var subscribeToSpaces = (context, { spaceKeys = [] }) => new Stream6(({ next }) => {
+  let unsubscribe;
+  const update = async () => {
+    const spaces = [
+      ...context.spaceManager.spaces.values()
+    ];
+    const filteredSpaces = spaces.filter((space) => !(spaceKeys == null ? void 0 : spaceKeys.length) || spaceKeys.some((spaceKey) => spaceKey.equals(space.key)));
+    next({
+      spaces: filteredSpaces.map((space) => {
+        const spaceMetadata = context.metadataStore.spaces.find((spaceMetadata2) => spaceMetadata2.key.equals(space.key));
+        return {
+          key: space.key,
+          isOpen: space.isOpen,
+          timeframe: spaceMetadata.latestTimeframe,
+          genesisFeed: space.genesisFeedKey,
+          controlFeed: space.controlFeedKey,
+          dataFeed: space.dataFeedKey
+        };
+      })
+    });
+  };
+  const timeout = setTimeout(async () => {
+    await context.initialized.wait();
+    unsubscribe = context.spaceManager.updated.on(() => update());
+    await update();
+  });
+  return () => {
+    unsubscribe == null ? void 0 : unsubscribe();
+    clearTimeout(timeout);
+  };
+});
+
+// packages/sdk/client-services/src/packlets/devtools/devtools.ts
+var DevtoolsHostEvents = class {
+  constructor() {
+    this.ready = new AsyncEvent();
+  }
+};
+var DevtoolsServiceImpl = class {
+  constructor(params) {
+    this.params = params;
+  }
+  events(request) {
+    return new Stream7(({ next }) => {
+      this.params.events.ready.on(() => {
+        next({
+          ready: {}
+        });
+      });
+    });
+  }
+  getConfig(request) {
+    throw new Error();
+  }
+  resetStorage(request) {
+    throw new Error();
+  }
+  enableDebugLogging(request) {
+    throw new Error();
+  }
+  disableDebugLogging(request) {
+    throw new Error();
+  }
+  subscribeToKeyringKeys(request) {
+    return subscribeToKeyringKeys({
+      keyring: this.params.context.keyring
+    });
+  }
+  subscribeToCredentialMessages(request) {
+    throw new Error();
+  }
+  subscribeToSpaces(request) {
+    return subscribeToSpaces(this.params.context, request);
+  }
+  subscribeToItems(request) {
+    throw new Error();
+  }
+  subscribeToFeeds(request) {
+    return subscribeToFeeds({
+      feedStore: this.params.context.feedStore
+    }, request);
+  }
+  subscribeToFeedBlocks(request) {
+    return subscribeToFeedBlocks({
+      feedStore: this.params.context.feedStore
+    }, request);
+  }
+  getSpaceSnapshot(request) {
+    throw new Error();
+  }
+  saveSpaceSnapshot(request) {
+    throw new Error();
+  }
+  clearSnapshots(request) {
+    throw new Error();
+  }
+  getNetworkPeers(request) {
+    throw new Error();
+  }
+  subscribeToNetworkTopics(request) {
+    throw new Error();
+  }
+  subscribeToSignalStatus(request) {
+    return subscribeToNetworkStatus({
+      networkManager: this.params.context.networkManager
+    });
+  }
+  subscribeToSignalTrace() {
+    return subscribeToSignalTrace({
+      networkManager: this.params.context.networkManager
+    });
+  }
+  subscribeToSwarmInfo() {
+    return subscribeToSwarmInfo({
+      networkManager: this.params.context.networkManager
+    });
+  }
+};
+
+// packages/sdk/client-services/src/packlets/identity/authenticator.ts
+import { verifyCredential } from "@dxos/credentials";
+import { log as log2 } from "@dxos/log";
+import { schema } from "@dxos/protocols";
+var createHaloAuthProvider = (signer) => async (nonce) => {
+  const credential = await signer.createCredential({
+    assertion: {
+      "@type": "dxos.halo.credentials.Auth"
+    },
+    subject: signer.getIssuer(),
+    nonce
+  });
+  return schema.getCodecForType("dxos.halo.credentials.Credential").encode(credential);
+};
+var createHaloAuthVerifier = (getDeviceSet) => async (nonce, auth) => {
+  const credential = schema.getCodecForType("dxos.halo.credentials.Credential").decode(auth);
+  const deviceSet = getDeviceSet();
+  const result = await verifyCredential(credential);
+  if (result.kind === "fail") {
+    log2("Invalid credential", {
+      result
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/authenticator.ts",
+      line: 34,
+      scope: void 0,
+      callSite: (f, a) => f(...a)
+    });
+    return false;
+  }
+  if (!credential.proof.nonce || !Buffer.from(nonce).equals(credential.proof.nonce)) {
+    log2("Invalid nonce", {
+      nonce,
+      credential
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/authenticator.ts",
+      line: 39,
+      scope: void 0,
+      callSite: (f, a) => f(...a)
+    });
+    return false;
+  }
+  if (!deviceSet.has(credential.issuer)) {
+    log2("Device not in allowed set", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/authenticator.ts",
+      line: 44,
+      scope: void 0,
+      callSite: (f, a) => f(...a)
+    });
+    return false;
+  }
+  return true;
+};
+
+// packages/sdk/client-services/src/packlets/identity/identity.ts
+import assert2 from "@dxos/node-std/assert";
+import { Event } from "@dxos/async";
+import { DeviceStateMachine, createCredentialSignerWithKey, createCredentialSignerWithChain, ProfileStateMachine } from "@dxos/credentials";
+import { failUndefined } from "@dxos/debug";
+import { writeMessages } from "@dxos/feed-store";
+import { log as log3 } from "@dxos/log";
+import { AdmittedFeed } from "@dxos/protocols/proto/dxos/halo/credentials";
+var Identity = class {
+  constructor({ space, signer, identityKey, deviceKey }) {
+    this.stateUpdate = new Event();
+    this._space = space;
+    this._signer = signer;
+    this.identityKey = identityKey;
+    this.deviceKey = deviceKey;
+    this._deviceStateMachine = new DeviceStateMachine(this.identityKey, this.deviceKey);
+    this._profileStateMachine = new ProfileStateMachine(this.identityKey);
+    this._space.onCredentialProcessed.set(async (credential) => {
+      await this._deviceStateMachine.process(credential);
+      await this._profileStateMachine.process(credential);
+      this.stateUpdate.emit();
+    });
+  }
+  get authorizedDeviceKeys() {
+    return this._deviceStateMachine.authorizedDeviceKeys;
+  }
+  async open() {
+    await this._space.open();
+  }
+  async close() {
+    await this._space.close();
+  }
+  async ready() {
+    await this._deviceStateMachine.deviceChainReady.wait();
+  }
+  get profileDocument() {
+    return this._profileStateMachine.profile;
+  }
+  get controlPipeline() {
+    return this._space.controlPipeline;
+  }
+  get haloSpaceKey() {
+    return this._space.key;
+  }
+  get haloGenesisFeedKey() {
+    return this._space.genesisFeedKey;
+  }
+  get haloDatabase() {
+    var _a;
+    return (_a = this._space.database) != null ? _a : failUndefined();
+  }
+  getAdmissionCredentials() {
+    return {
+      deviceKey: this.deviceKey,
+      controlFeedKey: this._space.controlFeedKey,
+      dataFeedKey: this._space.dataFeedKey
+    };
+  }
+  getIdentityCredentialSigner() {
+    assert2(this._deviceStateMachine.deviceCredentialChain, "Device credential chain is not ready.");
+    return createCredentialSignerWithChain(this._signer, this._deviceStateMachine.deviceCredentialChain, this.deviceKey);
+  }
+  getDeviceCredentialSigner() {
+    return createCredentialSignerWithKey(this._signer, this.deviceKey);
+  }
+  async admitDevice({ deviceKey, controlFeedKey, dataFeedKey }) {
+    log3("Admitting device:", {
+      identityKey: this.identityKey,
+      hostDevice: this.deviceKey,
+      deviceKey,
+      controlFeedKey,
+      dataFeedKey
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/identity.ts",
+      line: 137,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const signer = this.getIdentityCredentialSigner();
+    await writeMessages(this.controlPipeline.writer, [
+      await signer.createCredential({
+        subject: deviceKey,
+        assertion: {
+          "@type": "dxos.halo.credentials.AuthorizedDevice",
+          identityKey: this.identityKey,
+          deviceKey
+        }
+      }),
+      await signer.createCredential({
+        subject: controlFeedKey,
+        assertion: {
+          "@type": "dxos.halo.credentials.AdmittedFeed",
+          spaceKey: this.haloSpaceKey,
+          deviceKey,
+          identityKey: this.identityKey,
+          designation: AdmittedFeed.Designation.CONTROL
+        }
+      }),
+      await signer.createCredential({
+        subject: dataFeedKey,
+        assertion: {
+          "@type": "dxos.halo.credentials.AdmittedFeed",
+          spaceKey: this.haloSpaceKey,
+          deviceKey,
+          identityKey: this.identityKey,
+          designation: AdmittedFeed.Designation.DATA
+        }
+      })
+    ].map((credential) => ({
+      "@type": "dxos.echo.feed.CredentialsMessage",
+      credential
+    })));
+  }
+};
+
+// packages/sdk/client-services/src/packlets/identity/identity-manager.ts
+import assert3 from "@dxos/node-std/assert";
+import { Event as Event2 } from "@dxos/async";
+import { CredentialGenerator } from "@dxos/credentials";
+import { MOCK_AUTH_PROVIDER, MOCK_AUTH_VERIFIER, Space, Database, SpaceProtocol } from "@dxos/echo-db";
+import { log as log4 } from "@dxos/log";
+import { AdmittedFeed as AdmittedFeed2 } from "@dxos/protocols/proto/dxos/halo/credentials";
+var IdentityManager = class {
+  constructor(_metadataStore, _feedStore, _keyring, _networkManager, _modelFactory) {
+    this._metadataStore = _metadataStore;
+    this._feedStore = _feedStore;
+    this._keyring = _keyring;
+    this._networkManager = _networkManager;
+    this._modelFactory = _modelFactory;
+    this.stateUpdate = new Event2();
+  }
+  get identity() {
+    return this._identity;
+  }
+  async open() {
+    await this._metadataStore.load();
+    const identityRecord = this._metadataStore.getIdentityRecord();
+    if (identityRecord) {
+      this._identity = await this._constructIdentity(identityRecord);
+      await this._identity.open();
+      await this._identity.ready();
+      this.stateUpdate.emit();
+    }
+  }
+  async close() {
+    var _a;
+    await ((_a = this._identity) == null ? void 0 : _a.close());
+  }
+  async createIdentity({ displayName } = {}) {
+    assert3(!this._identity, "Identity already exists.");
+    log4("creating identity...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/identity-manager.ts",
+      line: 83,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const controlFeedKey = await this._keyring.createKey();
+    const identityRecord = {
+      identityKey: await this._keyring.createKey(),
+      deviceKey: await this._keyring.createKey(),
+      haloSpace: {
+        spaceKey: await this._keyring.createKey(),
+        genesisFeedKey: controlFeedKey,
+        writeControlFeedKey: controlFeedKey,
+        writeDataFeedKey: await this._keyring.createKey()
+      }
+    };
+    const identity = await this._constructIdentity(identityRecord);
+    await identity.open();
+    {
+      const generator = new CredentialGenerator(this._keyring, identityRecord.identityKey, identityRecord.deviceKey);
+      const credentials = [
+        ...await generator.createSpaceGenesis(identityRecord.haloSpace.spaceKey, identityRecord.haloSpace.genesisFeedKey),
+        await generator.createFeedAdmission(identityRecord.haloSpace.spaceKey, identityRecord.haloSpace.writeDataFeedKey, AdmittedFeed2.Designation.DATA)
+      ];
+      if (displayName) {
+        credentials.push(await generator.createProfileCredential({
+          displayName
+        }));
+      }
+      credentials.push(await generator.createDeviceAuthorization(identityRecord.deviceKey));
+      for (const credential of credentials) {
+        await identity.controlPipeline.writer.write({
+          "@type": "dxos.echo.feed.CredentialsMessage",
+          credential
+        });
+      }
+    }
+    await this._metadataStore.setIdentityRecord(identityRecord);
+    this._identity = identity;
+    await this._identity.ready();
+    this.stateUpdate.emit();
+    log4("created identity", {
+      identityKey: identity.identityKey,
+      deviceKey: identity.deviceKey
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/identity-manager.ts",
+      line: 142,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return identity;
+  }
+  async acceptIdentity(params) {
+    log4("accepting identity", {
+      params
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/identity-manager.ts",
+      line: 150,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    assert3(!this._identity, "Identity already exists.");
+    const identityRecord = {
+      identityKey: params.identityKey,
+      deviceKey: await this._keyring.createKey(),
+      haloSpace: {
+        spaceKey: params.haloSpaceKey,
+        genesisFeedKey: params.haloGenesisFeedKey,
+        writeControlFeedKey: await this._keyring.createKey(),
+        writeDataFeedKey: await this._keyring.createKey()
+      }
+    };
+    const identity = await this._constructIdentity(identityRecord);
+    await identity.open();
+    this._identity = identity;
+    await this._metadataStore.setIdentityRecord(identityRecord);
+    this.stateUpdate.emit();
+    return identity;
+  }
+  async _constructIdentity(identityRecord) {
+    assert3(!this._identity);
+    log4("constructing identity", {
+      identityRecord
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/identity-manager.ts",
+      line: 174,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    const space = await this._constructSpace({
+      spaceRecord: identityRecord.haloSpace,
+      swarmIdentity: {
+        peerKey: identityRecord.deviceKey,
+        credentialProvider: MOCK_AUTH_PROVIDER,
+        credentialAuthenticator: MOCK_AUTH_VERIFIER
+      }
+    });
+    log4("done", {
+      identityKey: identityRecord.identityKey
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/identity/identity-manager.ts",
+      line: 185,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    return new Identity({
+      space,
+      signer: this._keyring,
+      identityKey: identityRecord.identityKey,
+      deviceKey: identityRecord.deviceKey
+    });
+  }
+  async _constructSpace({ spaceRecord, swarmIdentity }) {
+    const controlFeed = await this._feedStore.openFeed(spaceRecord.writeControlFeedKey, {
+      writable: true
+    });
+    const dataFeed = await this._feedStore.openFeed(spaceRecord.writeDataFeedKey, {
+      writable: true
+    });
+    const genesisFeed = await this._feedStore.openFeed(spaceRecord.genesisFeedKey);
+    const protocol = new SpaceProtocol({
+      topic: spaceRecord.spaceKey,
+      identity: swarmIdentity,
+      networkManager: this._networkManager
+    });
+    return new Space({
+      spaceKey: spaceRecord.spaceKey,
+      protocol,
+      genesisFeed,
+      controlFeed,
+      dataFeed,
+      feedProvider: (feedKey) => this._feedStore.openFeed(feedKey),
+      databaseFactory: async ({ databaseBackend }) => new Database(this._modelFactory, databaseBackend, swarmIdentity.peerKey)
+    });
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/encoder.ts
+import base from "base-x";
+import { schema as schema2 } from "@dxos/protocols";
+var base62 = base("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+var codec = schema2.getCodecForType("dxos.client.services.Invitation");
+var InvitationEncoder = class {
+  static decode(text) {
+    return codec.decode(base62.decode(text));
+  }
+  static encode(invitation) {
+    return base62.encode(codec.encode(invitation));
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts
+import assert5 from "@dxos/node-std/assert";
+import { scheduleTask, sleep, Trigger } from "@dxos/async";
+import { Context } from "@dxos/context";
+import { generatePasscode } from "@dxos/credentials";
+import { failUndefined as failUndefined2 } from "@dxos/debug";
+import { PublicKey as PublicKey3 } from "@dxos/keys";
+import { log as log5 } from "@dxos/log";
+import { createTeleportProtocolFactory, StarTopology } from "@dxos/network-manager";
+import { schema as schema3 } from "@dxos/protocols";
+import { Invitation as Invitation2 } from "@dxos/protocols/proto/dxos/client/services";
+import { AuthenticationResponse } from "@dxos/protocols/proto/dxos/halo/invitations";
+
+// packages/sdk/client-services/src/packlets/invitations/invitations.ts
+import assert4 from "@dxos/node-std/assert";
+import { CancellableObservableProvider } from "@dxos/async";
+import { Invitation } from "@dxos/protocols/proto/dxos/client/services";
+var AUTHENTICATION_CODE_LENGTH = 6;
+var INVITATION_TIMEOUT = 3 * 6e4;
+var ON_CLOSE_DELAY = 500;
+var InvitationObservableProvider = class extends CancellableObservableProvider {
+  get invitation() {
+    return this._invitation;
+  }
+  setInvitation(invitation) {
+    this._invitation = invitation;
+  }
+};
+var AuthenticatingInvitationProvider = class extends InvitationObservableProvider {
+  constructor(_actions) {
+    super(() => this._actions.onCancel());
+    this._actions = _actions;
+  }
+  async authenticate(authenticationCode) {
+    return this._actions.onAuthenticate(authenticationCode);
+  }
+};
+var wrapObservable = async (observable) => {
+  return new Promise((resolve, reject) => {
+    const unsubscribe = observable.subscribe({
+      onSuccess: (invitation) => {
+        assert4(invitation.state === Invitation.State.SUCCESS);
+        unsubscribe();
+        resolve(invitation);
+      },
+      onError: (err) => {
+        unsubscribe();
+        reject(err);
+      }
+    });
+  });
+};
+
+// packages/sdk/client-services/src/packlets/invitations/invitations-handler.ts
+var AbstractInvitationsHandler = class {
+  constructor(_networkManager) {
+    this._networkManager = _networkManager;
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/rpc-extension.ts
+import { createProtoRpcPeer } from "@dxos/rpc";
+var RpcExtension = class {
+  constructor(_params) {
+    this._params = _params;
+  }
+  get initiator() {
+    return this._extensionContext.initiator;
+  }
+  get localPeerId() {
+    return this._extensionContext.localPeerId;
+  }
+  get remotePeerId() {
+    return this._extensionContext.remotePeerId;
+  }
+  get rpc() {
+    return this._rpc.rpc;
+  }
+  async onOpen(context) {
+    this._extensionContext = context;
+    const handlers = await this.getHandlers();
+    const port = context.createPort("rpc", {
+      contentType: 'application/x-protobuf; messageType="dxos.rpc.Message"'
+    });
+    this._rpc = createProtoRpcPeer({
+      ...this._params,
+      handlers,
+      port
+    });
+    await this._rpc.open();
+  }
+  async onClose(err) {
+    await this._rpc.close();
+  }
+  close() {
+    this._extensionContext.close();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts
+var HaloInvitationsHandler = class extends AbstractInvitationsHandler {
+  constructor(networkManager, _identityManager) {
+    super(networkManager);
+    this._identityManager = _identityManager;
+  }
+  createInvitation(context, options) {
+    var _a;
+    const { type, timeout = INVITATION_TIMEOUT, swarmKey } = options != null ? options : {};
+    assert5(type !== Invitation2.Type.OFFLINE);
+    const identity = (_a = this._identityManager.identity) != null ? _a : failUndefined2();
+    const invitation = {
+      type,
+      invitationId: PublicKey3.random().toHex(),
+      swarmKey: swarmKey != null ? swarmKey : PublicKey3.random(),
+      authenticationCode: generatePasscode(AUTHENTICATION_CODE_LENGTH)
+    };
+    const ctx = new Context({
+      onError: (err) => {
+        void ctx.dispose();
+        observable.callback.onError(err);
+      }
+    });
+    const observable = new InvitationObservableProvider(async () => {
+      await ctx.dispose();
+    });
+    let authenticationCode;
+    const complete = new Trigger();
+    const createExtension = () => {
+      const hostInvitationExtension = new HostHaloInvitationExtension({
+        requestAdmission: async () => {
+          var _a2, _b;
+          log5("responding with admission offer", {
+            host: identity.deviceKey
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+            line: 85,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          (_b = (_a2 = observable.callback).onAuthenticating) == null ? void 0 : _b.call(_a2, invitation);
+          return {
+            identityKey: identity.identityKey,
+            haloSpaceKey: identity.haloSpaceKey,
+            genesisFeedKey: identity.haloGenesisFeedKey
+          };
+        },
+        authenticate: async ({ authenticationCode: code }) => {
+          log5("received authentication request", {
+            authenticationCode: code
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+            line: 99,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          authenticationCode = code;
+          return {
+            status: AuthenticationResponse.Status.OK
+          };
+        },
+        presentAdmissionCredentials: async (credentials) => {
+          try {
+            if (invitation.type !== Invitation2.Type.INTERACTIVE_TESTING) {
+              if (invitation.authenticationCode === void 0 || invitation.authenticationCode !== authenticationCode) {
+                throw new Error(`invalid authentication code: ${authenticationCode}`);
+              }
+            }
+            log5("writing guest credentials", {
+              host: identity.deviceKey,
+              guest: credentials.deviceKey
+            }, {
+              file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+              line: 114,
+              scope: this,
+              callSite: (f, a) => f(...a)
+            });
+            await identity.admitDevice(credentials);
+            complete.wake(credentials.deviceKey);
+          } catch (err) {
+            observable.callback.onError(err);
+            throw err;
+          }
+        },
+        onOpen: () => {
+          scheduleTask(ctx, async () => {
+            var _a2, _b;
+            try {
+              log5("connected", {
+                host: identity.deviceKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                line: 130,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              (_b = (_a2 = observable.callback).onConnected) == null ? void 0 : _b.call(_a2, invitation);
+              const deviceKey = await complete.wait({
+                timeout
+              });
+              log5("admitted guest", {
+                host: identity.deviceKey,
+                guest: deviceKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                line: 133,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              observable.callback.onSuccess(invitation);
+            } catch (err) {
+              if (!observable.cancelled) {
+                log5.error("failed", err, {
+                  file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                  line: 137,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+                observable.callback.onError(err);
+              }
+            } finally {
+              await sleep(ON_CLOSE_DELAY);
+              await ctx.dispose();
+            }
+          });
+        }
+      });
+      return hostInvitationExtension;
+    };
+    scheduleTask(ctx, async () => {
+      var _a2, _b;
+      const topic = invitation.swarmKey;
+      const swarmConnection = await this._networkManager.joinSwarm({
+        topic,
+        peerId: topic,
+        protocolProvider: createTeleportProtocolFactory(async (teleport) => {
+          teleport.addExtension("dxos.halo.invitations", createExtension());
+        }),
+        topology: new StarTopology(topic)
+      });
+      ctx.onDispose(() => swarmConnection.close());
+      (_b = (_a2 = observable.callback).onConnecting) == null ? void 0 : _b.call(_a2, invitation);
+    });
+    return observable;
+  }
+  acceptInvitation(invitation, options) {
+    const { timeout = INVITATION_TIMEOUT } = options != null ? options : {};
+    const ctx = new Context({
+      onError: (err) => {
+        void ctx.dispose();
+        observable.callback.onError(err);
+      }
+    });
+    const authenticated = new Trigger();
+    const observable = new AuthenticatingInvitationProvider({
+      onCancel: async () => {
+        await ctx.dispose();
+      },
+      onAuthenticate: async (code) => {
+        authenticated.wake(code);
+      }
+    });
+    let connectionCount = 0;
+    const complete = new Trigger();
+    const createExtension = () => {
+      const extension = new GuestHaloInvitationExtension({
+        onOpen: () => {
+          scheduleTask(ctx, async () => {
+            var _a, _b, _c, _d;
+            try {
+              if (++connectionCount > 1) {
+                throw new Error(`multiple connections detected: ${connectionCount}`);
+              }
+              log5("connected", {}, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                line: 210,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              (_b = (_a = observable.callback).onConnected) == null ? void 0 : _b.call(_a, invitation);
+              log5("sending admission request", {}, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                line: 214,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              const { identityKey, haloSpaceKey, genesisFeedKey } = await extension.rpc.HaloHostService.requestAdmission();
+              if (invitation.type === void 0 || invitation.type === Invitation2.Type.INTERACTIVE) {
+                log5("guest waiting for authentication code...", {}, {
+                  file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                  line: 221,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+                (_d = (_c = observable.callback).onAuthenticating) == null ? void 0 : _d.call(_c, invitation);
+                const authenticationCode = await authenticated.wait({
+                  timeout
+                });
+                log5("sending authentication request", {}, {
+                  file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                  line: 224,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+                await extension.rpc.HaloHostService.authenticate({
+                  authenticationCode
+                });
+              }
+              const identity = await this._identityManager.acceptIdentity({
+                identityKey,
+                haloSpaceKey,
+                haloGenesisFeedKey: genesisFeedKey
+              });
+              log5("presenting admission credentials", {
+                guest: identity.deviceKey,
+                identityKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                line: 237,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              await extension.rpc.HaloHostService.presentAdmissionCredentials(identity.getAdmissionCredentials());
+              log5("admitted by host", {
+                guest: identity.deviceKey,
+                identityKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                line: 241,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              complete.wake(identityKey);
+            } catch (err) {
+              if (!observable.cancelled) {
+                log5.warn("auth failed", err, {
+                  file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/halo-invitations-handler.ts",
+                  line: 245,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+                observable.callback.onError(err);
+              }
+            } finally {
+              await ctx.dispose();
+            }
+          });
+        }
+      });
+      return extension;
+    };
+    scheduleTask(ctx, async () => {
+      var _a, _b;
+      assert5(invitation.swarmKey);
+      const topic = invitation.swarmKey;
+      const swarmConnection = await this._networkManager.joinSwarm({
+        topic,
+        peerId: PublicKey3.random(),
+        protocolProvider: createTeleportProtocolFactory(async (teleport) => {
+          teleport.addExtension("dxos.halo.invitations", createExtension());
+        }),
+        topology: new StarTopology(topic)
+      });
+      ctx.onDispose(() => swarmConnection.close());
+      (_b = (_a = observable.callback).onConnecting) == null ? void 0 : _b.call(_a, invitation);
+      invitation.identityKey = await complete.wait();
+      observable.callback.onSuccess(invitation);
+      await ctx.dispose();
+    });
+    return observable;
+  }
+};
+var HostHaloInvitationExtension = class extends RpcExtension {
+  constructor(_callbacks) {
+    super({
+      exposed: {
+        HaloHostService: schema3.getService("dxos.halo.invitations.HaloHostService")
+      }
+    });
+    this._callbacks = _callbacks;
+  }
+  async getHandlers() {
+    return {
+      HaloHostService: {
+        requestAdmission: async () => {
+          return this._callbacks.requestAdmission();
+        },
+        authenticate: async (credentials) => {
+          return this._callbacks.authenticate(credentials);
+        },
+        presentAdmissionCredentials: async (credentials) => {
+          return this._callbacks.presentAdmissionCredentials(credentials);
+        }
+      }
+    };
+  }
+  async onOpen(context) {
+    await super.onOpen(context);
+    this._callbacks.onOpen();
+  }
+};
+var GuestHaloInvitationExtension = class extends RpcExtension {
+  constructor(_callbacks) {
+    super({
+      requested: {
+        HaloHostService: schema3.getService("dxos.halo.invitations.HaloHostService")
+      }
+    });
+    this._callbacks = _callbacks;
+  }
+  async getHandlers() {
+    return {};
+  }
+  async onOpen(context) {
+    await super.onOpen(context);
+    this._callbacks.onOpen();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/invitations-proxy.ts
+import assert6 from "@dxos/node-std/assert";
+import { observableError } from "@dxos/async";
+import { log as log6 } from "@dxos/log";
+import { Invitation as Invitation3 } from "@dxos/protocols/proto/dxos/client/services";
+var AbstractInvitationsProxy = class {
+  constructor(_invitationsService) {
+    this._invitationsService = _invitationsService;
+  }
+  createInvitation(context, options) {
+    let invitationId;
+    const observable = new InvitationObservableProvider(async () => {
+      if (invitationId) {
+        await this._invitationsService.cancelInvitation({
+          invitationId
+        });
+      }
+    });
+    const invitation = {
+      ...this.getInvitationOptions(context),
+      ...options
+    };
+    const stream = this._invitationsService.createInvitation(invitation);
+    stream.subscribe((invitation2) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+      observable.setInvitation(invitation2);
+      switch (invitation2.state) {
+        case Invitation3.State.CONNECTING: {
+          assert6(invitation2.invitationId);
+          invitationId = invitation2.invitationId;
+          (_b = (_a = observable.callback).onConnecting) == null ? void 0 : _b.call(_a, invitation2);
+          break;
+        }
+        case Invitation3.State.CONNECTED: {
+          (_d = (_c = observable.callback).onConnected) == null ? void 0 : _d.call(_c, invitation2);
+          break;
+        }
+        case Invitation3.State.AUTHENTICATING: {
+          (_f = (_e = observable.callback).onAuthenticating) == null ? void 0 : _f.call(_e, invitation2);
+          break;
+        }
+        case Invitation3.State.SUCCESS: {
+          (_h = (_g = observable.callback).onSuccess) == null ? void 0 : _h.call(_g, invitation2);
+          break;
+        }
+        case Invitation3.State.CANCELLED: {
+          (_j = (_i = observable.callback).onCancelled) == null ? void 0 : _j.call(_i);
+          break;
+        }
+        default: {
+          log6.error(`Invalid state: ${invitation2.state}`, {}, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-proxy.ts",
+            line: 81,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      }
+    }, (err) => {
+      if (err) {
+        observableError(observable, err);
+      }
+    });
+    return observable;
+  }
+  acceptInvitation(invitation, options) {
+    assert6(invitation && invitation.swarmKey);
+    const observable = new AuthenticatingInvitationProvider({
+      onCancel: async () => {
+        var _a;
+        const invitationId = (_a = observable.invitation) == null ? void 0 : _a.invitationId;
+        assert6(invitationId);
+        await this._invitationsService.cancelInvitation({
+          invitationId
+        });
+      },
+      onAuthenticate: async (authenticationCode) => {
+        var _a;
+        const invitationId = (_a = observable.invitation) == null ? void 0 : _a.invitationId;
+        assert6(invitationId);
+        await this._invitationsService.authenticate({
+          invitationId,
+          authenticationCode
+        });
+      }
+    });
+    const stream = this._invitationsService.acceptInvitation({
+      ...invitation,
+      ...options
+    });
+    stream.subscribe((invitation2) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+      assert6(invitation2.invitationId);
+      observable.setInvitation(invitation2);
+      switch (invitation2.state) {
+        case Invitation3.State.CONNECTING: {
+          (_b = (_a = observable.callback).onConnecting) == null ? void 0 : _b.call(_a, invitation2);
+          break;
+        }
+        case Invitation3.State.CONNECTED: {
+          (_d = (_c = observable.callback).onConnected) == null ? void 0 : _d.call(_c, invitation2);
+          break;
+        }
+        case Invitation3.State.AUTHENTICATING: {
+          (_f = (_e = observable.callback).onAuthenticating) == null ? void 0 : _f.call(_e, invitation2);
+          break;
+        }
+        case Invitation3.State.SUCCESS: {
+          (_h = (_g = observable.callback).onSuccess) == null ? void 0 : _h.call(_g, invitation2);
+          break;
+        }
+        case Invitation3.State.CANCELLED: {
+          (_j = (_i = observable.callback).onCancelled) == null ? void 0 : _j.call(_i);
+          break;
+        }
+        default: {
+          log6.error(`Invalid state: ${invitation2.state}`, {}, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-proxy.ts",
+            line: 146,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      }
+    }, (err) => {
+      if (err) {
+        observableError(observable, err);
+      }
+    });
+    return observable;
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/halo-invitations-proxy.ts
+var HaloInvitationsProxy = class extends AbstractInvitationsProxy {
+  getInvitationOptions() {
+    return {};
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/invitations-service.ts
+import assert7 from "@dxos/node-std/assert";
+import { Stream as Stream8 } from "@dxos/codec-protobuf";
+import { log as log7 } from "@dxos/log";
+import { Invitation as Invitation4 } from "@dxos/protocols/proto/dxos/client/services";
+var AbstractInvitationsService = class {
+  constructor(_identityManager, _getInvitationsHandler) {
+    this._identityManager = _identityManager;
+    this._getInvitationsHandler = _getInvitationsHandler;
+    this._createInvitations = /* @__PURE__ */ new Map();
+    this._acceptInvitations = /* @__PURE__ */ new Map();
+  }
+  getLoggingContext() {
+    var _a;
+    return {
+      deviceKey: (_a = this._identityManager.identity) == null ? void 0 : _a.deviceKey
+    };
+  }
+  createInvitation(invitation) {
+    return new Stream8(({ next, close }) => {
+      const invitationsHandler = this._getInvitationsHandler();
+      const context = this.getContext(invitation);
+      log7("stream opened", this.getLoggingContext(), {
+        file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+        line: 43,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      let invitationId;
+      const { type, swarmKey } = invitation;
+      const observable = invitationsHandler.createInvitation(context, {
+        type,
+        swarmKey
+      });
+      observable.subscribe({
+        onConnecting: (invitation2) => {
+          assert7(invitation2.invitationId);
+          invitationId = invitation2.invitationId;
+          this._createInvitations.set(invitation2.invitationId, observable);
+          invitation2.state = Invitation4.State.CONNECTING;
+          next(invitation2);
+        },
+        onConnected: (invitation2) => {
+          assert7(invitation2.invitationId);
+          invitation2.state = Invitation4.State.CONNECTED;
+          next(invitation2);
+        },
+        onAuthenticating: (invitation2) => {
+          assert7(invitation2.invitationId);
+          invitation2.state = Invitation4.State.AUTHENTICATING;
+          next(invitation2);
+        },
+        onSuccess: (invitation2) => {
+          assert7(invitation2.invitationId);
+          invitation2.state = Invitation4.State.SUCCESS;
+          next(invitation2);
+          close();
+        },
+        onCancelled: () => {
+          assert7(invitationId);
+          invitation.invitationId = invitationId;
+          invitation.state = Invitation4.State.CANCELLED;
+          next(invitation);
+          close();
+        },
+        onTimeout: (err) => {
+          invitation.state = Invitation4.State.TIMEOUT;
+          close(err);
+        },
+        onError: (err) => {
+          invitation.state = Invitation4.State.ERROR;
+          close(err);
+        }
+      });
+      return (err) => {
+        const context2 = this.getLoggingContext();
+        if (err) {
+          log7.warn("stream closed", {
+            ...context2,
+            err
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+            line: 92,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        } else {
+          log7("stream closed", context2, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+            line: 94,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+        this._createInvitations.delete(invitation.invitationId);
+      };
+    });
+  }
+  acceptInvitation(invitation, options) {
+    return new Stream8(({ next, close }) => {
+      log7("stream opened", this.getLoggingContext(), {
+        file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+        line: 104,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+      const invitationsHandler = this._getInvitationsHandler();
+      let invitationId;
+      const observable = invitationsHandler.acceptInvitation(invitation, options);
+      observable.subscribe({
+        onConnecting: (invitation2) => {
+          assert7(invitation2.invitationId);
+          invitationId = invitation2.invitationId;
+          this._acceptInvitations.set(invitation2.invitationId, observable);
+          invitation2.state = Invitation4.State.CONNECTING;
+          next(invitation2);
+        },
+        onConnected: (invitation2) => {
+          assert7(invitation2.invitationId);
+          invitation2.state = Invitation4.State.CONNECTED;
+          next(invitation2);
+        },
+        onAuthenticating: (invitation2) => {
+          assert7(invitation2.invitationId);
+          invitation2.state = Invitation4.State.AUTHENTICATING;
+          next(invitation2);
+        },
+        onSuccess: (invitation2) => {
+          invitation2.state = Invitation4.State.SUCCESS;
+          next(invitation2);
+          close();
+        },
+        onCancelled: () => {
+          assert7(invitationId);
+          invitation.invitationId = invitationId;
+          invitation.state = Invitation4.State.CANCELLED;
+          next(invitation);
+          close();
+        },
+        onTimeout: (err) => {
+          invitation.state = Invitation4.State.TIMEOUT;
+          close(err);
+        },
+        onError: (err) => {
+          invitation.state = Invitation4.State.ERROR;
+          close(err);
+        }
+      });
+      return (err) => {
+        const context = this.getLoggingContext();
+        if (err) {
+          log7.warn("stream closed", {
+            ...context,
+            err
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+            line: 152,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        } else {
+          log7("stream closed", context, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+            line: 154,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+        this._acceptInvitations.delete(invitation.invitationId);
+      };
+    });
+  }
+  async authenticate({ invitationId, authenticationCode }) {
+    log7("authenticating...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+      line: 163,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    assert7(invitationId);
+    const observable = this._acceptInvitations.get(invitationId);
+    if (!observable) {
+      log7.warn("invalid invitation", {
+        invitationId
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+        line: 167,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    } else {
+      await observable.authenticate(authenticationCode);
+    }
+  }
+  async cancelInvitation(invitation) {
+    var _a;
+    log7("cancelling...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+      line: 174,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    assert7(invitation.invitationId);
+    const observable = (_a = this._createInvitations.get(invitation.invitationId)) != null ? _a : this._acceptInvitations.get(invitation.invitationId);
+    if (!observable) {
+      log7.warn("invalid invitation", {
+        invitationId: invitation.invitationId
+      }, {
+        file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/invitations-service.ts",
+        line: 179,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    } else {
+      await (observable == null ? void 0 : observable.cancel());
+    }
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/halo-invitations-service.ts
+var HaloInvitationsServiceImpl = class extends AbstractInvitationsService {
+  constructor(identityManager, invitationsHandler) {
+    super(identityManager, () => invitationsHandler);
+    this.invitationsHandler = invitationsHandler;
+  }
+  getContext(invitation) {
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts
+import assert8 from "@dxos/node-std/assert";
+import { scheduleTask as scheduleTask2, sleep as sleep2, Trigger as Trigger2 } from "@dxos/async";
+import { Context as Context2 } from "@dxos/context";
+import { createAdmissionCredentials, generatePasscode as generatePasscode2, getCredentialAssertion } from "@dxos/credentials";
+import { writeMessages as writeMessages2 } from "@dxos/feed-store";
+import { PublicKey as PublicKey4 } from "@dxos/keys";
+import { log as log8 } from "@dxos/log";
+import { createTeleportProtocolFactory as createTeleportProtocolFactory2, StarTopology as StarTopology2 } from "@dxos/network-manager";
+import { schema as schema4 } from "@dxos/protocols";
+import { Invitation as Invitation5 } from "@dxos/protocols/proto/dxos/client/services";
+import { AuthenticationResponse as AuthenticationResponse2 } from "@dxos/protocols/proto/dxos/halo/invitations";
+var MAX_OTP_ATTEMPTS = 3;
+var SpaceInvitationsHandler = class extends AbstractInvitationsHandler {
+  constructor(networkManager, _spaceManager, _signingContext, _keyring) {
+    super(networkManager);
+    this._spaceManager = _spaceManager;
+    this._signingContext = _signingContext;
+    this._keyring = _keyring;
+  }
+  createInvitation(space, options) {
+    let swarmConnection;
+    const { type, timeout = INVITATION_TIMEOUT, swarmKey } = options != null ? options : {};
+    assert8(type !== Invitation5.Type.OFFLINE);
+    assert8(space);
+    const invitation = {
+      type,
+      invitationId: PublicKey4.random().toHex(),
+      swarmKey: swarmKey != null ? swarmKey : PublicKey4.random(),
+      spaceKey: space.key,
+      authenticationCode: generatePasscode2(AUTHENTICATION_CODE_LENGTH)
+    };
+    const ctx = new Context2({
+      onError: (err) => {
+        void ctx.dispose();
+        observable.callback.onError(err);
+      }
+    });
+    const observable = new InvitationObservableProvider(async () => {
+      await (swarmConnection == null ? void 0 : swarmConnection.close());
+    });
+    let authenticationCode;
+    let authenticationRetry = 0;
+    const complete = new Trigger2();
+    const createExtension = () => {
+      let guestProfile;
+      const hostInvitationExtension = new HostSpaceInvitationExtension({
+        introduce: async ({ profile }) => {
+          var _a, _b;
+          log8("guest introduced itself", {
+            guestProfile: profile,
+            host: this._signingContext.deviceKey,
+            spaceKey: space.key
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+            line: 97,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          guestProfile = profile;
+          (_b = (_a = observable.callback).onAuthenticating) == null ? void 0 : _b.call(_a, invitation);
+        },
+        authenticate: async ({ authenticationCode: code }) => {
+          log8("received authentication request", {
+            authenticationCode: code
+          }, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+            line: 111,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+          let status = AuthenticationResponse2.Status.OK;
+          if (invitation.authenticationCode) {
+            if (authenticationRetry++ > MAX_OTP_ATTEMPTS) {
+              status = AuthenticationResponse2.Status.INVALID_OPT_ATTEMPTS;
+            } else if (code !== invitation.authenticationCode) {
+              status = AuthenticationResponse2.Status.INVALID_OTP;
+            } else {
+              authenticationCode = code;
+            }
+          }
+          return {
+            status
+          };
+        },
+        requestAdmission: async ({ identityKey, deviceKey, controlFeedKey, dataFeedKey }) => {
+          try {
+            if (invitation.type !== Invitation5.Type.INTERACTIVE_TESTING) {
+              if (invitation.authenticationCode === void 0 || invitation.authenticationCode !== authenticationCode) {
+                throw new Error(`invalid authentication code: ${authenticationCode}`);
+              }
+            }
+            log8("writing guest credentials", {
+              host: this._signingContext.deviceKey,
+              guest: deviceKey
+            }, {
+              file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+              line: 135,
+              scope: this,
+              callSite: (f, a) => f(...a)
+            });
+            const credentials = await createAdmissionCredentials(this._signingContext.credentialSigner, identityKey, deviceKey, space.key, controlFeedKey, dataFeedKey, space.genesisFeedKey, guestProfile);
+            assert8(credentials[0]["@type"] === "dxos.echo.feed.CredentialsMessage");
+            const spaceMemberCredential = credentials[0].credential;
+            assert8(getCredentialAssertion(spaceMemberCredential)["@type"] === "dxos.halo.credentials.SpaceMember");
+            await writeMessages2(space.controlPipeline.writer, credentials);
+            complete.wake(deviceKey);
+            return {
+              credential: spaceMemberCredential
+            };
+          } catch (err) {
+            observable.callback.onError(err);
+            throw err;
+          }
+        },
+        onOpen: () => {
+          scheduleTask2(ctx, async () => {
+            var _a, _b;
+            try {
+              log8("connected", {
+                host: this._signingContext.deviceKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                line: 169,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              (_b = (_a = observable.callback).onConnected) == null ? void 0 : _b.call(_a, invitation);
+              const deviceKey = await complete.wait({
+                timeout
+              });
+              log8("admitted guest", {
+                host: this._signingContext.deviceKey,
+                guest: deviceKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                line: 172,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              observable.callback.onSuccess(invitation);
+            } catch (err) {
+              if (!observable.cancelled) {
+                log8.error("failed", err, {
+                  file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                  line: 176,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+                observable.callback.onError(err);
+              }
+            } finally {
+              await sleep2(ON_CLOSE_DELAY);
+              await ctx.dispose();
+            }
+          });
+        }
+      });
+      return hostInvitationExtension;
+    };
+    scheduleTask2(ctx, async () => {
+      var _a, _b;
+      const topic = invitation.swarmKey;
+      const swarmConnection2 = await this._networkManager.joinSwarm({
+        topic,
+        peerId: topic,
+        protocolProvider: createTeleportProtocolFactory2(async (teleport) => {
+          teleport.addExtension("dxos.halo.invitations", createExtension());
+        }),
+        topology: new StarTopology2(topic)
+      });
+      ctx.onDispose(() => swarmConnection2.close());
+      (_b = (_a = observable.callback).onConnecting) == null ? void 0 : _b.call(_a, invitation);
+    });
+    return observable;
+  }
+  acceptInvitation(invitation, options) {
+    const { timeout = INVITATION_TIMEOUT } = options != null ? options : {};
+    const ctx = new Context2({
+      onError: (err) => {
+        void ctx.dispose();
+        observable.callback.onError(err);
+      }
+    });
+    const authenticated = new Trigger2();
+    const observable = new AuthenticatingInvitationProvider({
+      onCancel: async () => {
+        await ctx.dispose();
+      },
+      onAuthenticate: async (code) => {
+        authenticated.wake(code);
+      }
+    });
+    let connectionCount = 0;
+    const complete = new Trigger2();
+    const createExtension = () => {
+      const extension = new GuestSpaceInvitationExtension({
+        onOpen: () => {
+          scheduleTask2(ctx, async () => {
+            var _a, _b, _c, _d;
+            try {
+              if (++connectionCount > 1) {
+                throw new Error(`multiple connections detected: ${connectionCount}`);
+              }
+              log8("connected", {
+                guest: this._signingContext.deviceKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                line: 247,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              (_b = (_a = observable.callback).onConnected) == null ? void 0 : _b.call(_a, invitation);
+              log8("introduce", {
+                guest: this._signingContext.deviceKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                line: 251,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              await extension.rpc.SpaceHostService.introduce({
+                profile: this._signingContext.profile
+              });
+              if (invitation.type === void 0 || invitation.type === Invitation5.Type.INTERACTIVE) {
+                for (let attempt = 1; attempt <= MAX_OTP_ATTEMPTS; attempt++) {
+                  log8("guest waiting for authentication code...", {}, {
+                    file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                    line: 260,
+                    scope: this,
+                    callSite: (f, a) => f(...a)
+                  });
+                  (_d = (_c = observable.callback).onAuthenticating) == null ? void 0 : _d.call(_c, invitation);
+                  const authenticationCode = await authenticated.wait({
+                    timeout
+                  });
+                  log8("sending authentication request", {}, {
+                    file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                    line: 264,
+                    scope: this,
+                    callSite: (f, a) => f(...a)
+                  });
+                  const response = await extension.rpc.SpaceHostService.authenticate({
+                    authenticationCode
+                  });
+                  if (response.status === void 0 || response.status === AuthenticationResponse2.Status.OK) {
+                    break;
+                  }
+                  if (response.status === AuthenticationResponse2.Status.INVALID_OTP) {
+                    if (attempt === MAX_OTP_ATTEMPTS) {
+                      throw new Error(`Maximum retry attempts: ${MAX_OTP_ATTEMPTS}`);
+                    } else {
+                      log8("retrying invalid code", {
+                        attempt
+                      }, {
+                        file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                        line: 274,
+                        scope: this,
+                        callSite: (f, a) => f(...a)
+                      });
+                      authenticated.reset();
+                    }
+                  }
+                }
+              }
+              const controlFeedKey = await this._keyring.createKey();
+              const dataFeedKey = await this._keyring.createKey();
+              log8("request admission", {
+                guest: this._signingContext.deviceKey
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                line: 285,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              const { credential } = await extension.rpc.SpaceHostService.requestAdmission({
+                identityKey: this._signingContext.identityKey,
+                deviceKey: this._signingContext.deviceKey,
+                controlFeedKey,
+                dataFeedKey
+              });
+              const assertion = getCredentialAssertion(credential);
+              assert8(assertion["@type"] === "dxos.halo.credentials.SpaceMember", "Invalid credential");
+              assert8(credential.subject.id.equals(this._signingContext.identityKey));
+              const space = await this._spaceManager.acceptSpace({
+                spaceKey: assertion.spaceKey,
+                genesisFeedKey: assertion.genesisFeedKey,
+                controlFeedKey,
+                dataFeedKey
+              });
+              log8("admitted by host", {
+                guest: this._signingContext.deviceKey,
+                spaceKey: space.key
+              }, {
+                file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                line: 308,
+                scope: this,
+                callSite: (f, a) => f(...a)
+              });
+              complete.wake();
+            } catch (err) {
+              if (!observable.cancelled) {
+                log8.warn("auth failed", err, {
+                  file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/invitations/space-invitations-handler.ts",
+                  line: 312,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+                observable.callback.onError(err);
+              }
+            } finally {
+              await ctx.dispose();
+            }
+          });
+        }
+      });
+      return extension;
+    };
+    scheduleTask2(ctx, async () => {
+      var _a, _b;
+      assert8(invitation.swarmKey);
+      const topic = invitation.swarmKey;
+      const swarmConnection = await this._networkManager.joinSwarm({
+        topic,
+        peerId: PublicKey4.random(),
+        protocolProvider: createTeleportProtocolFactory2(async (teleport) => {
+          teleport.addExtension("dxos.halo.invitations", createExtension());
+        }),
+        topology: new StarTopology2(topic)
+      });
+      ctx.onDispose(() => swarmConnection.close());
+      (_b = (_a = observable.callback).onConnecting) == null ? void 0 : _b.call(_a, invitation);
+      await complete.wait();
+      observable.callback.onSuccess(invitation);
+      await ctx.dispose();
+    });
+    return observable;
+  }
+};
+var HostSpaceInvitationExtension = class extends RpcExtension {
+  constructor(_callbacks) {
+    super({
+      exposed: {
+        SpaceHostService: schema4.getService("dxos.halo.invitations.SpaceHostService")
+      }
+    });
+    this._callbacks = _callbacks;
+  }
+  async getHandlers() {
+    return {
+      SpaceHostService: {
+        introduce: async (params) => {
+          return this._callbacks.introduce(params);
+        },
+        authenticate: async (credentials) => {
+          return this._callbacks.authenticate(credentials);
+        },
+        requestAdmission: async (credentials) => {
+          return this._callbacks.requestAdmission(credentials);
+        }
+      }
+    };
+  }
+  async onOpen(context) {
+    await super.onOpen(context);
+    this._callbacks.onOpen();
+  }
+};
+var GuestSpaceInvitationExtension = class extends RpcExtension {
+  constructor(_callbacks) {
+    super({
+      requested: {
+        SpaceHostService: schema4.getService("dxos.halo.invitations.SpaceHostService")
+      }
+    });
+    this._callbacks = _callbacks;
+  }
+  async getHandlers() {
+    return {};
+  }
+  async onOpen(context) {
+    await super.onOpen(context);
+    this._callbacks.onOpen();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/space-invitations-proxy.ts
+var SpaceInvitationsProxy = class extends AbstractInvitationsProxy {
+  getInvitationOptions(context) {
+    return {
+      spaceKey: context
+    };
+  }
+};
+
+// packages/sdk/client-services/src/packlets/invitations/space-invitations-service.ts
+import assert9 from "@dxos/node-std/assert";
+var SpaceInvitationsServiceImpl = class extends AbstractInvitationsService {
+  constructor(identityManager, invitationsHandler, _getSpaceManager) {
+    super(identityManager, invitationsHandler);
+    this.invitationsHandler = invitationsHandler;
+    this._getSpaceManager = _getSpaceManager;
+  }
+  getContext(invitation) {
+    assert9(invitation.spaceKey);
+    const spaceManager = this._getSpaceManager();
+    const space = spaceManager.spaces.get(invitation.spaceKey);
+    assert9(space);
+    return space;
+  }
+};
+
+// packages/sdk/client-services/src/packlets/services/service-context.ts
+import { Trigger as Trigger3 } from "@dxos/async";
+import { failUndefined as failUndefined3 } from "@dxos/debug";
+import { MOCK_AUTH_PROVIDER as MOCK_AUTH_PROVIDER2, MOCK_AUTH_VERIFIER as MOCK_AUTH_VERIFIER2, valueEncoding, DataServiceSubscriptions, MetadataStore, SpaceManager } from "@dxos/echo-db";
+import { FeedFactory, FeedStore } from "@dxos/feed-store";
+import { Keyring } from "@dxos/keyring";
+import { log as log9 } from "@dxos/log";
+var ServiceContext = class {
+  constructor(storage, networkManager, modelFactory) {
+    this.storage = storage;
+    this.networkManager = networkManager;
+    this.modelFactory = modelFactory;
+    this.initialized = new Trigger3();
+    this.dataServiceSubscriptions = new DataServiceSubscriptions();
+    this.metadataStore = new MetadataStore(storage.createDirectory("metadata"));
+    this.keyring = new Keyring(storage.createDirectory("keyring"));
+    this.feedStore = new FeedStore({
+      factory: new FeedFactory({
+        root: storage.createDirectory("feeds"),
+        signer: this.keyring,
+        hypercore: {
+          valueEncoding
+        }
+      })
+    });
+    this.identityManager = new IdentityManager(this.metadataStore, this.feedStore, this.keyring, networkManager, modelFactory);
+    this.haloInvitations = new HaloInvitationsHandler(this.networkManager, this.identityManager);
+  }
+  async open() {
+    log9("opening...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-context.ts",
+      line: 78,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this.identityManager.open();
+    if (this.identityManager.identity) {
+      await this._initialize();
+    }
+    log9("opened", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-context.ts",
+      line: 83,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async close() {
+    var _a;
+    log9("closing...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-context.ts",
+      line: 87,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this.identityManager.close();
+    await ((_a = this.spaceManager) == null ? void 0 : _a.close());
+    await this.feedStore.close();
+    await this.networkManager.close();
+    this.dataServiceSubscriptions.clear();
+    log9("closed", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-context.ts",
+      line: 93,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async reset() {
+    log9("resetting...", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-context.ts",
+      line: 97,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this.close();
+    await this.storage.reset();
+    log9("reset", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-context.ts",
+      line: 100,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async createIdentity(params = {}) {
+    const identity = await this.identityManager.createIdentity(params);
+    this.dataServiceSubscriptions.registerSpace(identity.haloSpaceKey, identity.haloDatabase.createDataServiceHost());
+    await this._initialize();
+    return identity;
+  }
+  async _initialize() {
+    var _a;
+    const identity = (_a = this.identityManager.identity) != null ? _a : failUndefined3();
+    const signingContext = {
+      credentialProvider: MOCK_AUTH_PROVIDER2,
+      credentialAuthenticator: MOCK_AUTH_VERIFIER2,
+      credentialSigner: identity.getIdentityCredentialSigner(),
+      identityKey: identity.identityKey,
+      deviceKey: identity.deviceKey,
+      profile: identity.profileDocument
+    };
+    const spaceManager = new SpaceManager({
+      metadataStore: this.metadataStore,
+      feedStore: this.feedStore,
+      networkManager: this.networkManager,
+      keyring: this.keyring,
+      dataServiceSubscriptions: this.dataServiceSubscriptions,
+      modelFactory: this.modelFactory,
+      signingContext
+    });
+    await spaceManager.open();
+    this.spaceManager = spaceManager;
+    this.spaceInvitations = new SpaceInvitationsHandler(this.networkManager, this.spaceManager, signingContext, this.keyring);
+    this.initialized.wake();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/services/service-definitions.ts
+import { schema as schema5 } from "@dxos/protocols";
+import { createServiceBundle } from "@dxos/rpc";
+var clientServiceBundle = createServiceBundle({
+  HaloInvitationsService: schema5.getService("dxos.client.services.HaloInvitationsService"),
+  DevicesService: schema5.getService("dxos.client.services.DevicesService"),
+  SpaceInvitationsService: schema5.getService("dxos.client.services.SpaceInvitationsService"),
+  SpacesService: schema5.getService("dxos.client.services.SpacesService"),
+  SpaceService: schema5.getService("dxos.client.SpaceService"),
+  DataService: schema5.getService("dxos.echo.service.DataService"),
+  ProfileService: schema5.getService("dxos.client.ProfileService"),
+  SystemService: schema5.getService("dxos.client.SystemService"),
+  DevtoolsHost: schema5.getService("dxos.devtools.host.DevtoolsHost"),
+  TracingService: schema5.getService("dxos.devtools.host.TracingService")
+});
+
+// packages/sdk/client-services/src/packlets/services/service-host.ts
+import { raise } from "@dxos/debug";
+import { DataServiceImpl } from "@dxos/echo-db";
+import { log as log10 } from "@dxos/log";
+import { ModelFactory } from "@dxos/model-factory";
+import { ObjectModel } from "@dxos/object-model";
+import { TextModel } from "@dxos/text-model";
+
+// packages/sdk/client-services/src/packlets/identity/devices-service-impl.ts
+import { EventSubscriptions as EventSubscriptions3 } from "@dxos/async";
+import { Stream as Stream9 } from "@dxos/codec-protobuf";
+var DevicesServiceImpl = class {
+  constructor(_identityManager) {
+    this._identityManager = _identityManager;
+  }
+  updateDevice() {
+    throw new Error("Method not implemented.");
+  }
+  queryDevices() {
+    return new Stream9(({ next }) => {
+      const update = () => {
+        var _a;
+        const deviceKeys = (_a = this._identityManager.identity) == null ? void 0 : _a.authorizedDeviceKeys;
+        if (!deviceKeys) {
+          next({
+            devices: []
+          });
+        } else {
+          next({
+            devices: Array.from(deviceKeys.values()).map((key) => ({
+              deviceKey: key
+            }))
+          });
+        }
+      };
+      const dispose = new EventSubscriptions3();
+      dispose.add(this._identityManager.stateUpdate.on(() => {
+        update();
+        if (this._identityManager.identity) {
+          dispose.add(this._identityManager.identity.stateUpdate.on(() => {
+            update();
+          }));
+        }
+      }));
+      update();
+      return () => dispose.clear();
+    });
+  }
+};
+
+// packages/sdk/client-services/src/packlets/spaces/spaces-service.ts
+var SpacesServiceImpl = class {
+  async createSpace() {
+    throw new Error();
+  }
+  querySpaces() {
+    throw new Error();
+  }
+  queryMembers(query) {
+    throw new Error();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/storage/storage.ts
+import jsondown from "jsondown";
+import leveljs from "level-js";
+import memdown from "memdown";
+import { InvalidConfigError } from "@dxos/errors";
+import { Runtime } from "@dxos/protocols/proto/dxos/config";
+import { createStorage, StorageType } from "@dxos/random-access-storage";
+import { isNode } from "@dxos/util";
+var StorageDriver = Runtime.Client.Storage.StorageDriver;
+var createStorageObjects = (config) => {
+  const { path = "dxos/storage", storageType, keyStorage, persistent = false } = config != null ? config : {};
+  if (persistent && storageType === StorageDriver.RAM) {
+    throw new InvalidConfigError("RAM storage cannot be used in persistent mode.");
+  }
+  if (!persistent && storageType !== void 0 && storageType !== StorageDriver.RAM) {
+    throw new InvalidConfigError("Cannot use a persistent storage in not persistent mode.");
+  }
+  if (persistent && keyStorage === StorageDriver.RAM) {
+    throw new InvalidConfigError("RAM key storage cannot be used in persistent mode.");
+  }
+  if (!persistent && keyStorage !== StorageDriver.RAM && keyStorage !== void 0) {
+    throw new InvalidConfigError("Cannot use a persistent key storage in not persistent mode.");
+  }
+  return {
+    storage: createStorage({
+      type: persistent ? toStorageType(storageType) : StorageType.RAM,
+      root: `${path}/`
+    }),
+    keyStorage: createKeyStorage(`${path}/keystore`, persistent ? toKeyStorageType(keyStorage) : "ram")
+  };
+};
+var createKeyStorage = (path, type) => {
+  const defaultedType = type != null ? type : isNode() ? "jsondown" : "leveljs";
+  switch (defaultedType) {
+    case "leveljs":
+      return leveljs(path);
+    case "jsondown":
+      return jsondown(path);
+    case "ram":
+      return memdown();
+    default:
+      throw new InvalidConfigError(`Invalid key storage type: ${defaultedType}`);
+  }
+};
+var toStorageType = (type) => {
+  switch (type) {
+    case void 0:
+      return void 0;
+    case StorageDriver.RAM:
+      return StorageType.RAM;
+    case StorageDriver.CHROME:
+      return StorageType.CHROME;
+    case StorageDriver.FIREFOX:
+      return StorageType.FIREFOX;
+    case StorageDriver.IDB:
+      return StorageType.IDB;
+    case StorageDriver.NODE:
+      return StorageType.NODE;
+    default:
+      throw new Error(`Invalid storage type: ${StorageDriver[type]}`);
+  }
+};
+var toKeyStorageType = (type) => {
+  switch (type) {
+    case void 0:
+      return void 0;
+    case StorageDriver.RAM:
+      return "ram";
+    case StorageDriver.LEVELJS:
+      return "leveljs";
+    case StorageDriver.JSONDOWN:
+      return "jsondown";
+    default:
+      throw new Error(`Invalid key storage type: ${StorageDriver[type]}`);
+  }
+};
+
+// packages/sdk/client-services/src/packlets/services/service-registry.ts
+var ServiceRegistry = class {
+  constructor(_serviceBundle, _handlers) {
+    this._serviceBundle = _serviceBundle;
+    this._handlers = _handlers;
+  }
+  get descriptors() {
+    return this._serviceBundle;
+  }
+  get services() {
+    return this._handlers;
+  }
+};
+
+// packages/sdk/client-services/src/packlets/services/service-host.ts
+var createDefaultModelFactory = () => {
+  return new ModelFactory().registerModel(ObjectModel).registerModel(TextModel);
+};
+var ClientServicesHost = class {
+  constructor({
+    config,
+    modelFactory = createDefaultModelFactory(),
+    networkManager
+  }) {
+    this._config = config;
+    this._modelFactory = modelFactory;
+    this._networkManager = networkManager;
+  }
+  get descriptors() {
+    return this._serviceRegistry.descriptors;
+  }
+  get services() {
+    return this._serviceRegistry.services;
+  }
+  async open() {
+    var _a;
+    await this._initialize();
+    const deviceKey = (_a = this._serviceContext.identityManager.identity) == null ? void 0 : _a.deviceKey;
+    log10("opening...", {
+      deviceKey
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-host.ts",
+      line: 69,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._initialize();
+    await this._serviceContext.open();
+    log10("opened", {
+      deviceKey
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-host.ts",
+      line: 72,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async close() {
+    var _a;
+    const deviceKey = (_a = this._serviceContext.identityManager.identity) == null ? void 0 : _a.deviceKey;
+    log10("closing...", {
+      deviceKey
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-host.ts",
+      line: 77,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await this._serviceContext.close();
+    log10("closed", {
+      deviceKey
+    }, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/services/service-host.ts",
+      line: 79,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+  }
+  async _initialize() {
+    const { storage } = createStorageObjects(this._config.get("runtime.client.storage", {}));
+    this._serviceContext = new ServiceContext(storage, this._networkManager, this._modelFactory);
+    this._serviceRegistry = new ServiceRegistry(clientServiceBundle, {
+      HaloInvitationsService: new HaloInvitationsServiceImpl(this._serviceContext.identityManager, this._serviceContext.haloInvitations),
+      DevicesService: new DevicesServiceImpl(this._serviceContext.identityManager),
+      SpaceInvitationsService: new SpaceInvitationsServiceImpl(this._serviceContext.identityManager, () => {
+        var _a;
+        return (_a = this._serviceContext.spaceInvitations) != null ? _a : raise(new Error("SpaceInvitations not initialized"));
+      }, () => {
+        var _a;
+        return (_a = this._serviceContext.spaceManager) != null ? _a : raise(new Error("SpaceManager not initialized"));
+      }),
+      SpacesService: new SpacesServiceImpl(),
+      DataService: new DataServiceImpl(this._serviceContext.dataServiceSubscriptions),
+      ProfileService: new ProfileServiceImpl(this._serviceContext),
+      SpaceService: new SpaceServiceImpl(this._serviceContext),
+      SystemService: new SystemServiceImpl(this._config, this._serviceContext),
+      TracingService: new TracingServiceImpl(this._config),
+      DevtoolsHost: new DevtoolsServiceImpl({
+        events: new DevtoolsHostEvents(),
+        config: this._config,
+        context: this._serviceContext
+      })
+    });
+  }
+};
+
+// packages/sdk/client-services/src/packlets/services/service-proxy.ts
+import { asyncTimeout } from "@dxos/async";
+import { RemoteServiceConnectionTimeout } from "@dxos/errors";
+import { createProtoRpcPeer as createProtoRpcPeer2 } from "@dxos/rpc";
+var ClientServicesProxy = class {
+  constructor(port, _timeout = 3e4) {
+    this._timeout = _timeout;
+    this._proxy = createProtoRpcPeer2({
+      requested: clientServiceBundle,
+      exposed: {},
+      handlers: {},
+      port
+    });
+  }
+  get proxy() {
+    return this._proxy;
+  }
+  get descriptors() {
+    return clientServiceBundle;
+  }
+  get services() {
+    return this._proxy.rpc;
+  }
+  async open() {
+    await asyncTimeout(this._proxy.open(), this._timeout, new RemoteServiceConnectionTimeout());
+  }
+  async close() {
+    await this._proxy.close();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/vault/iframe-runtime.ts
+import { WebRTCTransportService } from "@dxos/network-manager";
+import { createProtoRpcPeer as createProtoRpcPeer3 } from "@dxos/rpc";
+
+// packages/sdk/client-services/src/packlets/vault/services.ts
+import { schema as schema6 } from "@dxos/protocols";
+var iframeServiceBundle = {
+  IframeService: schema6.getService("dxos.iframe.IframeService"),
+  BridgeService: schema6.getService("dxos.mesh.bridge.BridgeService")
+};
+var workerServiceBundle = {
+  WorkerService: schema6.getService("dxos.iframe.WorkerService")
+};
+
+// packages/sdk/client-services/src/packlets/vault/iframe-runtime.ts
+var IFrameRuntime = class {
+  constructor({ systemPort, workerAppPort, windowAppPort }) {
+    this._transportService = new WebRTCTransportService();
+    this._systemPort = systemPort;
+    this._windowAppPort = windowAppPort;
+    this._workerAppPort = workerAppPort;
+    this._systemRpc = createProtoRpcPeer3({
+      requested: workerServiceBundle,
+      exposed: iframeServiceBundle,
+      handlers: {
+        BridgeService: this._transportService,
+        IframeService: {
+          async heartbeat() {
+          }
+        }
+      },
+      port: this._systemPort,
+      timeout: 200
+    });
+    this._workerAppPort.subscribe((msg) => this._windowAppPort.send(msg));
+    this._windowAppPort.subscribe((msg) => this._workerAppPort.send(msg));
+  }
+  async open(origin) {
+    await this._systemRpc.open();
+    await this._systemRpc.rpc.WorkerService.start({
+      origin
+    });
+  }
+  async close() {
+    await this._systemRpc.rpc.WorkerService.stop();
+    await this._systemRpc.close();
+  }
+};
+
+// packages/sdk/client-services/src/packlets/vault/worker-runtime.ts
+import { Trigger as Trigger5 } from "@dxos/async";
+import { MemorySignalManager, MemorySignalManagerContext, WebsocketSignalManager } from "@dxos/messaging";
+import { NetworkManager, WebRTCTransportProxyFactory } from "@dxos/network-manager";
+
+// packages/sdk/client-services/src/packlets/vault/worker-session.ts
+import assert10 from "@dxos/node-std/assert";
+import { Trigger as Trigger4 } from "@dxos/async";
+import { log as log11, logInfo } from "@dxos/log";
+import { createProtoRpcPeer as createProtoRpcPeer4 } from "@dxos/rpc";
+import { Callback } from "@dxos/util";
+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 WorkerSession = class {
+  constructor({ getServices, systemPort, appPort, options = {
+    heartbeatInterval: 1e3
+  } }) {
+    this._startTrigger = new Trigger4();
+    this.onClose = new Callback();
+    assert10(options);
+    assert10(getServices);
+    this._options = options;
+    this._getServices = getServices;
+    this._clientRpc = createProtoRpcPeer4({
+      exposed: clientServiceBundle,
+      handlers: {
+        HaloInvitationsService: async () => (await this._getServices()).services.HaloInvitationsService,
+        DevicesService: async () => (await this._getServices()).services.DevicesService,
+        SpaceInvitationsService: async () => (await this._getServices()).services.SpaceInvitationsService,
+        SpacesService: async () => (await this._getServices()).services.SpacesService,
+        SpaceService: async () => (await this._getServices()).services.SpaceService,
+        DataService: async () => (await this._getServices()).services.DataService,
+        ProfileService: async () => (await this._getServices()).services.ProfileService,
+        SystemService: async () => (await this._getServices()).services.SystemService,
+        DevtoolsHost: async () => (await this._getServices()).services.DevtoolsHost,
+        TracingService: async () => (await this._getServices()).services.TracingService
+      },
+      port: appPort
+    });
+    this._iframeRpc = createProtoRpcPeer4({
+      requested: iframeServiceBundle,
+      exposed: workerServiceBundle,
+      handlers: {
+        WorkerService: {
+          start: async (request) => {
+            this.origin = request.origin;
+            this._startTrigger.wake();
+          },
+          stop: async () => {
+            setTimeout(async () => {
+              try {
+                await this.close();
+              } catch (err) {
+                log11.catch(err, {}, {
+                  file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/vault/worker-session.ts",
+                  line: 89,
+                  scope: this,
+                  callSite: (f, a) => f(...a)
+                });
+              }
+            });
+          }
+        }
+      },
+      port: systemPort,
+      timeout: 1e3
+    });
+    this.bridgeService = this._iframeRpc.rpc.BridgeService;
+  }
+  async open() {
+    log11.info("opening..", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/vault/worker-session.ts",
+      line: 103,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    await Promise.all([
+      this._clientRpc.open(),
+      this._iframeRpc.open()
+    ]);
+    await this._startTrigger.wait({
+      timeout: 3e3
+    });
+    this._heartbeatTimer = setInterval(async () => {
+      try {
+        await this._iframeRpc.rpc.IframeService.heartbeat();
+      } catch (err1) {
+        log11.warn("Heartbeat failed", {
+          err: err1
+        }, {
+          file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/vault/worker-session.ts",
+          line: 115,
+          scope: this,
+          callSite: (f, a) => f(...a)
+        });
+        try {
+          await this.close();
+        } catch (err) {
+          log11.catch(err, {}, {
+            file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/vault/worker-session.ts",
+            line: 119,
+            scope: this,
+            callSite: (f, a) => f(...a)
+          });
+        }
+      }
+    }, this._options.heartbeatInterval);
+  }
+  async close() {
+    log11.info("closing..", {}, {
+      file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/vault/worker-session.ts",
+      line: 126,
+      scope: this,
+      callSite: (f, a) => f(...a)
+    });
+    try {
+      await this.onClose.callIfSet();
+    } catch (err) {
+      log11.catch(err, {}, {
+        file: "/home/runner/work/dxos/dxos/packages/sdk/client-services/src/packlets/vault/worker-session.ts",
+        line: 130,
+        scope: this,
+        callSite: (f, a) => f(...a)
+      });
+    }
+    if (this._heartbeatTimer !== void 0) {
+      clearInterval(this._heartbeatTimer);
+    }
+    await Promise.all([
+      this._clientRpc.close(),
+      this._iframeRpc.close()
+    ]);
+  }
+};
+__decorate([
+  logInfo
+], WorkerSession.prototype, "origin", void 0);
+
+// packages/sdk/client-services/src/packlets/vault/worker-runtime.ts
+var WorkerRuntime = class {
+  constructor(_configProvider) {
+    this._configProvider = _configProvider;
+    this._transportFactory = new WebRTCTransportProxyFactory();
+    this._ready = new Trigger5();
+    this.sessions = /* @__PURE__ */ new Set();
+  }
+  async start() {
+    try {
+      this._config = await this._configProvider();
+      const signalServer = this._config.get("runtime.services.signal.server");
+      this._clientServices = new ClientServicesHost({
+        config: this._config,
+        networkManager: new NetworkManager({
+          log: true,
+          signalManager: signalServer ? new WebsocketSignalManager([
+            signalServer
+          ]) : new MemorySignalManager(new MemorySignalManagerContext()),
+          transportFactory: this._transportFactory
+        })
+      });
+      await this._clientServices.open();
+      this._ready.wake(void 0);
+    } catch (err) {
+      this._ready.wake(err);
+    }
+  }
+  async stop() {
+    await this._clientServices.close();
+  }
+  async createSession({ appPort, systemPort }) {
+    const session = new WorkerSession({
+      getServices: async () => {
+        const error = await this._ready.wait();
+        if (error !== void 0) {
+          throw error;
+        }
+        return this._clientServices;
+      },
+      appPort,
+      systemPort,
+      readySignal: this._ready
+    });
+    session.onClose.set(async () => {
+      this.sessions.delete(session);
+      this._reconnectWebrtc();
+    });
+    await session.open();
+    this.sessions.add(session);
+    this._reconnectWebrtc();
+  }
+  _reconnectWebrtc() {
+    if (this._sessionForNetworking) {
+      if (!this.sessions.has(this._sessionForNetworking)) {
+        this._sessionForNetworking = void 0;
+      }
+    }
+    if (!this._sessionForNetworking) {
+      const selected = Array.from(this.sessions).find((session) => session.bridgeService);
+      if (selected) {
+        this._sessionForNetworking = selected;
+        this._transportFactory.setBridgeService(selected.bridgeService);
+      } else {
+        this._transportFactory.setBridgeService(void 0);
+      }
+    }
+  }
+};
+export {
+  AUTHENTICATION_CODE_LENGTH,
+  AbstractInvitationsHandler,
+  AbstractInvitationsProxy,
+  AbstractInvitationsService,
+  AuthenticatingInvitationProvider,
+  ClientServicesHost,
+  ClientServicesProxy,
+  DevtoolsHostEvents,
+  DevtoolsServiceImpl,
+  HaloInvitationsHandler,
+  HaloInvitationsProxy,
+  HaloInvitationsServiceImpl,
+  IFrameRuntime,
+  INVITATION_TIMEOUT,
+  Identity,
+  IdentityManager,
+  InvitationEncoder,
+  InvitationObservableProvider,
+  ON_CLOSE_DELAY,
+  ProfileServiceImpl,
+  ServiceContext,
+  ServiceRegistry,
+  SpaceInvitationsHandler,
+  SpaceInvitationsProxy,
+  SpaceInvitationsServiceImpl,
+  SpaceServiceImpl,
+  SystemServiceImpl,
+  TracingServiceImpl,
+  WorkerRuntime,
+  WorkerSession,
+  clientServiceBundle,
+  createDefaultModelFactory,
+  createHaloAuthProvider,
+  createHaloAuthVerifier,
+  createStorageObjects,
+  getNetworkPeers,
+  subscribeToFeedBlocks,
+  subscribeToFeeds,
+  subscribeToNetworkStatus,
+  subscribeToNetworkTopics,
+  subscribeToSignalTrace,
+  subscribeToSpaces,
+  subscribeToSwarmInfo,
+  wrapObservable
+};
+//# sourceMappingURL=index.mjs.map