@dxos/client-services 0.10.0 → 0.11.1

package/src/packlets/identity/identity-manager.ts

@@ -1,3 +1,7 @@
+import * as EffectContext from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
 //
 // Copyright 2022 DXOS.org
 //
@@ -6,11 +10,11 @@ import platform from 'platform';
 import { Event } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { CredentialGenerator, createCredentialSignerWithKey, createDidFromIdentityKey } from '@dxos/credentials';
-import { type IMetadataStore, type SpaceManager, type SwarmIdentity } from '@dxos/echo-host';
-import { type EdgeConnection } from '@dxos/edge-client';
-import { type FeedStore } from '@dxos/feed-store';
+import { failUndefined } from '@dxos/debug';
+import { type EdgeConnection, EdgeConnectionService } from '@dxos/edge-client';
+import { type FeedStore, FeedStoreService } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
-import { type KeyringApi } from '@dxos/keyring';
+import { type KeyringApi, KeyringApiService } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { Device, DeviceKind } from '@dxos/protocols/proto/dxos/client/services';
@@ -29,6 +33,8 @@ import { Timeframe } from '@dxos/timeframe';
 import { trace as Trace } from '@dxos/tracing';
 import { deferFunction, isNode, isTauri } from '@dxos/util';
 
+import { type IMetadataStore, IMetadataStoreService } from '../metadata';
+import { type SpaceManager, SpaceManagerService, type SwarmIdentity } from '../space';
 import { createAuthProvider } from './authenticator';
 import { Identity } from './identity';
 
@@ -77,8 +83,36 @@ export type IdentityManagerProps = {
   devicePresenceOfflineTimeout?: number;
 };
 
+/**
+ * Resolves the active identity when it becomes available.
+ */
+export type IdentityProvider = () => Identity;
+
+/**
+ * Effect service tag for {@link IdentityProvider}.
+ */
+export class IdentityProviderService extends EffectContext.Tag('@dxos/client-services/IdentityProvider')<
+  IdentityProviderService,
+  IdentityProvider
+>() {}
+
+/**
+ * Builds an {@link IdentityProvider} from an {@link IdentityManager}.
+ */
+export const identityProviderFromManager =
+  (identityManager: IdentityManager): IdentityProvider =>
+  () =>
+    identityManager.identity ?? failUndefined();
+
+/**
+ * Effect service tag for {@link IdentityManager}.
+ */
+export class IdentityManagerService extends EffectContext.Tag('@dxos/client-services/IdentityManager')<
+  IdentityManagerService,
+  IdentityManager
+>() {}
+
 // TODO(dmaretskyi): Rename: represents the peer's state machine.
-@Trace.resource()
 export class IdentityManager {
   readonly stateUpdate = new Event();
 
@@ -418,3 +452,37 @@ export class IdentityManager {
     });
   }
 }
+
+export type IdentityManagerLayerOptions = Pick<
+  IdentityManagerProps,
+  'devicePresenceAnnounceInterval' | 'devicePresenceOfflineTimeout' | 'edgeFeatures'
+>;
+
+/**
+ * Effect Layer constructing an {@link IdentityManager} from ambient service dependencies.
+ */
+export const IdentityManagerLayer = (
+  options: IdentityManagerLayerOptions = {},
+): Layer.Layer<
+  IdentityManagerService,
+  never,
+  IMetadataStoreService | KeyringApiService | FeedStoreService | SpaceManagerService
+> =>
+  Layer.effect(
+    IdentityManagerService,
+    Effect.gen(function* () {
+      const metadataStore = yield* IMetadataStoreService;
+      const keyring = yield* KeyringApiService;
+      const feedStore = yield* FeedStoreService;
+      const spaceManager = yield* SpaceManagerService;
+      const edgeConnection = yield* Effect.serviceOption(EdgeConnectionService);
+      return new IdentityManager({
+        metadataStore,
+        keyring,
+        feedStore,
+        spaceManager,
+        edgeConnection: Option.getOrUndefined(edgeConnection),
+        ...options,
+      });
+    }),
+  );

package/src/packlets/identity/identity-recovery-manager.ts

@@ -2,12 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
+import * as EffectContext from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Option from 'effect/Option';
+
 import { type Context } from '@dxos/context';
 import { generateSeedPhrase, keyPairFromSeedPhrase } from '@dxos/credentials';
 import { sign } from '@dxos/crypto';
-import { type EdgeHttpClient } from '@dxos/edge-client';
+import { type EdgeHttpClient, EdgeHttpClientService } from '@dxos/edge-client';
 import { invariant } from '@dxos/invariant';
-import { type KeyringApi } from '@dxos/keyring';
+import { type KeyringApi, KeyringApiService } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
@@ -23,16 +28,33 @@ import {
 import { Timeframe } from '@dxos/timeframe';
 
 import { type Identity } from './identity';
-import { type JoinIdentityProps } from './identity-manager';
+import { IdentityManagerService, type JoinIdentityProps } from './identity-manager';
+
+/**
+ * Effect service tag for {@link EdgeIdentityRecoveryManager}.
+ */
+export class EdgeIdentityRecoveryManagerService extends EffectContext.Tag(
+  '@dxos/client-services/EdgeIdentityRecoveryManager',
+)<EdgeIdentityRecoveryManagerService, EdgeIdentityRecoveryManager>() {}
+
+export type AcceptRecoveredIdentity = (params: JoinIdentityProps) => Promise<Identity>;
 
 export class EdgeIdentityRecoveryManager {
+  private _acceptRecoveredIdentity?: AcceptRecoveredIdentity;
+
   constructor(
     private readonly _keyring: KeyringApi,
     private readonly _edgeClient: EdgeHttpClient | undefined,
     private readonly _identityProvider: () => Identity | undefined,
-    private readonly _acceptRecoveredIdentity: (params: JoinIdentityProps) => Promise<Identity>,
   ) {}
 
+  /**
+   * Wires identity acceptance after the composing stack is fully constructed.
+   */
+  setAcceptRecoveredIdentity(acceptRecoveredIdentity: AcceptRecoveredIdentity): void {
+    this._acceptRecoveredIdentity = acceptRecoveredIdentity;
+  }
+
   public async createRecoveryCredential({
     data,
   }: CreateRecoveryCredentialRequest): Promise<{ recoveryCode: string | undefined }> {
@@ -127,7 +149,7 @@ export class EdgeIdentityRecoveryManager {
 
     const response = await this._edgeClient.recoverIdentity(ctx, request);
 
-    await this._acceptRecoveredIdentity({
+    await this.#acceptRecoveredIdentity({
       authorizedDeviceCredential: decodeCredential(response.deviceAuthCredential),
       haloGenesisFeedKey: PublicKey.fromHex(response.genesisFeedKey),
       haloSpaceKey: PublicKey.fromHex(response.haloSpaceKey),
@@ -159,7 +181,7 @@ export class EdgeIdentityRecoveryManager {
 
     const response = await this._edgeClient.recoverIdentity(ctx, request);
 
-    await this._acceptRecoveredIdentity({
+    await this.#acceptRecoveredIdentity({
       authorizedDeviceCredential: decodeCredential(response.deviceAuthCredential),
       haloGenesisFeedKey: PublicKey.fromHex(response.genesisFeedKey),
       haloSpaceKey: PublicKey.fromHex(response.haloSpaceKey),
@@ -199,7 +221,7 @@ export class EdgeIdentityRecoveryManager {
 
     log.info('recovering identity', response);
 
-    await this._acceptRecoveredIdentity({
+    await this.#acceptRecoveredIdentity({
       authorizedDeviceCredential: decodeCredential(response.deviceAuthCredential),
       haloGenesisFeedKey: PublicKey.fromHex(response.genesisFeedKey),
       haloSpaceKey: PublicKey.fromHex(response.haloSpaceKey),
@@ -209,6 +231,11 @@ export class EdgeIdentityRecoveryManager {
       dataFeedKey: await this._keyring.createKey(),
     });
   }
+
+  #acceptRecoveredIdentity(params: JoinIdentityProps): Promise<Identity> {
+    invariant(this._acceptRecoveredIdentity, 'acceptRecoveredIdentity not set');
+    return this._acceptRecoveredIdentity(params);
+  }
 }
 
 const decodeCredential = (credentialBase64: string) => {
@@ -216,3 +243,25 @@ const decodeCredential = (credentialBase64: string) => {
   const codec = schema.getCodecForType('dxos.halo.credentials.Credential');
   return codec.decode(credentialBytes);
 };
+
+/**
+ * Effect Layer constructing a dormant {@link EdgeIdentityRecoveryManager}.
+ */
+export const EdgeIdentityRecoveryManagerLayer = (): Layer.Layer<
+  EdgeIdentityRecoveryManagerService,
+  never,
+  KeyringApiService | IdentityManagerService
+> =>
+  Layer.effect(
+    EdgeIdentityRecoveryManagerService,
+    Effect.gen(function* () {
+      const keyring = yield* KeyringApiService;
+      const edgeClient = yield* Effect.serviceOption(EdgeHttpClientService);
+      const identityManager = yield* IdentityManagerService;
+      return new EdgeIdentityRecoveryManager(
+        keyring,
+        Option.getOrUndefined(edgeClient),
+        () => identityManager.identity,
+      );
+    }),
+  );

package/src/packlets/identity/identity-service.test.ts

@@ -2,12 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Runtime from 'effect/Runtime';
 import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
+import { EffectEx } from '@dxos/effect';
 import { PublicKey } from '@dxos/keys';
-import { type Identity, type IdentityService } from '@dxos/protocols/proto/dxos/client/services';
+import { subscribeStream } from '@dxos/protocols';
+import { type Identity } from '@dxos/protocols/proto/dxos/client/services';
 
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
@@ -15,7 +18,7 @@ import { IdentityServiceImpl } from './identity-service';
 
 describe('IdentityService', () => {
   let serviceContext: ServiceContext;
-  let identityService: IdentityService;
+  let identityService: IdentityServiceImpl;
 
   beforeEach(async () => {
     serviceContext = await createServiceContext();
@@ -29,14 +32,16 @@ describe('IdentityService', () => {
 
   describe('createIdentity', () => {
     test('creates a new identity', async () => {
-      const identity = await identityService.createIdentity({});
+      const identity = await EffectEx.runPromise(identityService['IdentityService.createIdentity']({}));
 
       expect(identity.identityKey).to.be.instanceof(PublicKey);
       expect(identity.spaceKey).to.be.instanceof(PublicKey);
     });
 
     test('creates a new identity with a display name', async () => {
-      const identity = await identityService.createIdentity({ profile: { displayName: 'Example' } });
+      const identity = await EffectEx.runPromise(
+        identityService['IdentityService.createIdentity']({ profile: { displayName: 'Example' } }),
+      );
 
       expect(identity.identityKey).to.be.instanceof(PublicKey);
       expect(identity.spaceKey).to.be.instanceof(PublicKey);
@@ -44,12 +49,14 @@ describe('IdentityService', () => {
     });
 
     test('fails to create identity if one already exists', async () => {
-      await identityService.createIdentity({});
-      await expect(identityService.createIdentity({})).rejects.toThrowError('Identity already exists');
+      await EffectEx.runPromise(identityService['IdentityService.createIdentity']({}));
+      await expect(EffectEx.runPromise(identityService['IdentityService.createIdentity']({}))).rejects.toThrowError(
+        'Identity already exists',
+      );
     });
 
     test('creates identity with no spaces', async () => {
-      await identityService.createIdentity({});
+      await EffectEx.runPromise(identityService['IdentityService.createIdentity']({}));
       const dataSpaces = [...(serviceContext.dataSpaceManager?.spaces?.values() ?? [])];
       expect(dataSpaces.length).to.eq(0);
     });
@@ -59,36 +66,38 @@ describe('IdentityService', () => {
 
   describe('updateProfile', () => {
     test('updates profile', async () => {
-      const identity = await identityService.createIdentity({});
+      const identity = await EffectEx.runPromise(identityService['IdentityService.createIdentity']({}));
       expect(identity.profile?.displayName).to.be.undefined;
 
-      const updatedIdentity = await identityService.updateProfile({ displayName: 'Example' });
+      const updatedIdentity = await EffectEx.runPromise(
+        identityService['IdentityService.updateProfile']({ displayName: 'Example' }),
+      );
       expect(updatedIdentity.profile?.displayName).to.equal('Example');
     });
   });
 
   describe('queryIdentity', () => {
     test('returns undefined if no identity is available', async () => {
-      const query = identityService.queryIdentity();
+      const stream = identityService['IdentityService.queryIdentity']();
       const result = new Trigger<Identity | undefined>();
-      query.subscribe(({ identity }) => {
-        result.wake(identity);
+      const cleanup = subscribeStream(Runtime.defaultRuntime, stream, {
+        onData: ({ identity }) => result.wake(identity),
       });
-      onTestFinished(() => query.close());
+      onTestFinished(cleanup);
       expect(await result.wait()).to.be.undefined;
     });
 
     test('updates when identity is created', async () => {
-      const query = identityService.queryIdentity();
+      const stream = identityService['IdentityService.queryIdentity']();
       let result = new Trigger<Identity | undefined>();
-      query.subscribe(({ identity }) => {
-        result.wake(identity);
+      const cleanup = subscribeStream(Runtime.defaultRuntime, stream, {
+        onData: ({ identity }) => result.wake(identity),
       });
-      onTestFinished(() => query.close());
+      onTestFinished(cleanup);
       expect(await result.wait()).to.be.undefined;
 
       result = new Trigger<Identity | undefined>();
-      const identity = await identityService.createIdentity({});
+      const identity = await EffectEx.runPromise(identityService['IdentityService.createIdentity']({}));
       expect(await result.wait()).to.deep.equal(identity);
     });
   });

package/src/packlets/identity/identity-service.ts

@@ -2,8 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type RequestOptions } from '@dxos/codec-protobuf';
-import { Stream } from '@dxos/codec-protobuf/stream';
+import * as Effect from 'effect/Effect';
+import * as EffectStream from 'effect/Stream';
+
 import { Context, Resource } from '@dxos/context';
 import { createCredential, signPresentation } from '@dxos/credentials';
 import { invariant } from '@dxos/invariant';
@@ -11,20 +12,22 @@ import { type KeyringApi } from '@dxos/keyring';
 import {
   type CreateIdentityRequest,
   type CreateRecoveryCredentialRequest,
+  type CreateRecoveryCredentialResponse,
   type Identity as IdentityProto,
-  type IdentityService,
   type QueryIdentityResponse,
   type RecoverIdentityRequest,
+  type RequestRecoveryChallengeResponse,
   type SignPresentationRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
-import { type Presentation, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type Credential, type Presentation, type ProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { type IdentityService } from '@dxos/protocols/rpc';
 
 import { type Identity } from './identity';
 import { type CreateIdentityOptions, type IdentityManager } from './identity-manager';
 import { type EdgeIdentityRecoveryManager } from './identity-recovery-manager';
 
-export class IdentityServiceImpl extends Resource implements IdentityService {
-  constructor(
+export class IdentityServiceImpl extends Resource implements IdentityService.Handlers {
+  'constructor'(
     private readonly _identityManager: IdentityManager,
     private readonly _recoveryManager: EdgeIdentityRecoveryManager,
     private readonly _keyring: KeyringApi,
@@ -34,91 +37,131 @@ export class IdentityServiceImpl extends Resource implements IdentityService {
     super();
   }
 
-  async createIdentity(request: CreateIdentityRequest, options?: RequestOptions): Promise<IdentityProto> {
-    const ctx = options?.ctx ?? Context.default();
-    await this._createIdentity({ profile: request.profile, deviceProfile: request.deviceProfile }, ctx);
-    return this._getIdentity()!;
+  ['IdentityService.createIdentity'](request: CreateIdentityRequest): Effect.Effect<IdentityProto, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const ctx = Context.default();
+        await this._createIdentity({ profile: request.profile, deviceProfile: request.deviceProfile }, ctx);
+        return this._getIdentity()!;
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  queryIdentity(): Stream<QueryIdentityResponse> {
-    return new Stream(({ next }) => {
-      const emitNext = () => next({ identity: this._getIdentity() });
+  ['IdentityService.queryIdentity'](): EffectStream.Stream<QueryIdentityResponse, Error> {
+    return EffectStream.async<QueryIdentityResponse, Error>((emit) => {
+      // Omit `identity` entirely when absent: an explicit `undefined` would still drive the optional
+      // protobuf codec, which dereferences the missing message and throws.
+      const emitNext = () => {
+        const identity = this._getIdentity();
+        void emit.single(identity ? { identity } : {});
+      };
 
       emitNext();
-      return this._identityManager.stateUpdate.on(emitNext);
+      const unsubscribe = this._identityManager.stateUpdate.on(emitNext);
+      return Effect.sync(() => unsubscribe());
     });
   }
 
-  private _getIdentity(): IdentityProto | undefined {
-    if (!this._identityManager.identity) {
-      return undefined;
-    }
-
-    return {
-      did: this._identityManager.identity.did,
-      identityKey: this._identityManager.identity.identityKey,
-      spaceKey: this._identityManager.identity.space.key,
-      profile: this._identityManager.identity.profileDocument,
-    };
-  }
-
-  async updateProfile(profile: ProfileDocument): Promise<IdentityProto> {
-    invariant(this._identityManager.identity, 'Identity not initialized.');
-    await this._identityManager.updateProfile(profile);
-    await this._onProfileUpdate?.(this._identityManager.identity.profileDocument);
-    return this._getIdentity()!;
+  ['IdentityService.updateProfile'](profile: ProfileDocument): Effect.Effect<IdentityProto, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        invariant(this._identityManager.identity, 'Identity not initialized.');
+        await this._identityManager.updateProfile(profile);
+        await this._onProfileUpdate?.(this._identityManager.identity.profileDocument);
+        return this._getIdentity()!;
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async createRecoveryCredential(request: CreateRecoveryCredentialRequest) {
-    return this._recoveryManager.createRecoveryCredential(request);
+  ['IdentityService.createRecoveryCredential'](
+    request: CreateRecoveryCredentialRequest,
+  ): Effect.Effect<CreateRecoveryCredentialResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => this._recoveryManager.createRecoveryCredential(request),
+      catch: (error) => error as Error,
+    });
   }
 
-  async requestRecoveryChallenge(_request: void, options?: RequestOptions) {
-    return this._recoveryManager.requestRecoveryChallenge(options?.ctx ?? Context.default());
+  ['IdentityService.requestRecoveryChallenge'](): Effect.Effect<RequestRecoveryChallengeResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => this._recoveryManager.requestRecoveryChallenge(Context.default()),
+      catch: (error) => error as Error,
+    });
   }
 
-  async recoverIdentity(request: RecoverIdentityRequest, options?: RequestOptions): Promise<IdentityProto> {
-    const ctx = options?.ctx ?? Context.default();
-    if (request.recoveryCode) {
-      await this._recoveryManager.recoverIdentity(ctx, { recoveryCode: request.recoveryCode });
-    } else if (request.external) {
-      await this._recoveryManager.recoverIdentityWithExternalSignature(ctx, request.external);
-    } else if (request.token) {
-      await this._recoveryManager.recoverIdentityWithToken(ctx, { token: request.token });
-    } else if (request.recoveryProof) {
-      await this._recoveryManager.recoverIdentityWithToken(ctx, { recoveryProof: request.recoveryProof });
-    } else {
-      throw new Error('Invalid request.');
-    }
-
-    return this._getIdentity()!;
+  ['IdentityService.recoverIdentity'](request: RecoverIdentityRequest): Effect.Effect<IdentityProto, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const ctx = Context.default();
+        if (request.recoveryCode) {
+          await this._recoveryManager.recoverIdentity(ctx, { recoveryCode: request.recoveryCode });
+        } else if (request.external) {
+          await this._recoveryManager.recoverIdentityWithExternalSignature(ctx, request.external);
+        } else if (request.token) {
+          await this._recoveryManager.recoverIdentityWithToken(ctx, { token: request.token });
+        } else if (request.recoveryProof) {
+          await this._recoveryManager.recoverIdentityWithToken(ctx, { recoveryProof: request.recoveryProof });
+        } else {
+          throw new Error('Invalid request.');
+        }
+
+        return this._getIdentity()!;
+      },
+      catch: (error) => error as Error,
+    });
   }
 
   // TODO(burdon): Rename createPresentation?
-  async signPresentation({ presentation, nonce }: SignPresentationRequest): Promise<Presentation> {
-    invariant(this._identityManager.identity, 'Identity not initialized.');
-
-    return await signPresentation({
-      presentation,
-      signer: this._keyring,
-      signerKey: this._identityManager.identity.deviceKey,
-      chain: this._identityManager.identity.deviceCredentialChain,
-      nonce,
+  ['IdentityService.signPresentation'](request: SignPresentationRequest): Effect.Effect<Presentation, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const { presentation, nonce } = request;
+        invariant(this._identityManager.identity, 'Identity not initialized.');
+
+        return await signPresentation({
+          presentation,
+          signer: this._keyring,
+          signerKey: this._identityManager.identity.deviceKey,
+          chain: this._identityManager.identity.deviceCredentialChain,
+          nonce,
+        });
+      },
+      catch: (error) => error as Error,
     });
   }
 
-  async createAuthCredential() {
-    const identity = this._identityManager.identity;
+  ['IdentityService.createAuthCredential'](): Effect.Effect<Credential, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const identity = this._identityManager.identity;
+
+        invariant(identity, 'Identity not initialized.');
+
+        return await createCredential({
+          assertion: { '@type': 'dxos.halo.credentials.Auth' },
+          issuer: identity.identityKey,
+          subject: identity.identityKey,
+          chain: identity.deviceCredentialChain,
+          signingKey: identity.deviceKey,
+          signer: this._keyring,
+        });
+      },
+      catch: (error) => error as Error,
+    });
+  }
 
-    invariant(identity, 'Identity not initialized.');
+  private '_getIdentity'(): IdentityProto | undefined {
+    if (!this._identityManager.identity) {
+      return undefined;
+    }
 
-    return await createCredential({
-      assertion: { '@type': 'dxos.halo.credentials.Auth' },
-      issuer: identity.identityKey,
-      subject: identity.identityKey,
-      chain: identity.deviceCredentialChain,
-      signingKey: identity.deviceKey,
-      signer: this._keyring,
-    });
+    return {
+      did: this._identityManager.identity.did,
+      identityKey: this._identityManager.identity.identityKey,
+      spaceKey: this._identityManager.identity.space.key,
+      profile: this._identityManager.identity.profileDocument,
+    };
   }
 }

package/src/packlets/identity/identity.test.ts

@@ -7,15 +7,7 @@ import { describe, expect, onTestFinished, test } from 'vitest';
 import { Event } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { CredentialGenerator, createDidFromIdentityKey, verifyCredential } from '@dxos/credentials';
-import {
-  MetadataStore,
-  MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER,
-  Space,
-  SpaceProtocol,
-  createIdFromSpaceKey,
-  valueEncoding,
-} from '@dxos/echo-host';
+import { createIdFromSpaceKey } from '@dxos/echo-protocol';
 import { type EdgeConnection, type MessageListener } from '@dxos/edge-client';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
 import { type FeedWrapper } from '@dxos/feed-store';
@@ -29,6 +21,9 @@ import { AdmittedFeed } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { StorageType, createStorage } from '@dxos/random-access-storage';
 import { BlobStore } from '@dxos/teleport-extension-object-sync';
 
+import { MetadataStore } from '../metadata';
+import { valueEncoding } from '../pipeline';
+import { MOCK_AUTH_PROVIDER, MOCK_AUTH_VERIFIER, Space, SpaceProtocol } from '../space';
 import { Identity } from './identity';
 
 const createStores = () => {

package/src/packlets/identity/identity.ts

@@ -13,7 +13,6 @@ import {
   createCredentialSignerWithKey,
 } from '@dxos/credentials';
 import { type Signer } from '@dxos/crypto';
-import { type Space } from '@dxos/echo-host';
 import { type EdgeConnection } from '@dxos/edge-client';
 import { type FeedWrapper, writeMessages } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
@@ -32,6 +31,7 @@ import { type Presence } from '@dxos/teleport-extension-gossip';
 import { trace } from '@dxos/tracing';
 import { type ComplexMap, ComplexSet } from '@dxos/util';
 
+import { type Space } from '../space';
 import { EdgeFeedReplicator } from '../spaces';
 import { TrustedKeySetAuthVerifier } from './authenticator';
 
@@ -50,7 +50,6 @@ export type IdentityProps = {
 /**
  * Agent identity manager, which includes the agent's Halo space.
  */
-@trace.resource()
 export class Identity {
   public readonly space: Space;
   private readonly _signer: Signer;

package/src/packlets/invitations/edge-invitation-handler.ts

@@ -42,7 +42,6 @@ export type EdgeInvitationConfig = {
   retryJitter?: number;
 };
 
-@trace.resource()
 export class EdgeInvitationHandler implements FlowLockHolder {
   private _flowLock: MutexGuard | undefined;