@dxos/client-services 0.10.0 → 0.11.1

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

@@ -3,10 +3,10 @@
 //
 
 import type { AutomergeUrl } from '@automerge/automerge-repo';
+import * as Effect from 'effect/Effect';
+import * as EffectStream from 'effect/Stream';
 
 import { SubscriptionList, UpdateScheduler, scheduleTask } from '@dxos/async';
-import { type RequestOptions } from '@dxos/codec-protobuf';
-import { Stream } from '@dxos/codec-protobuf/stream';
 import { Context } from '@dxos/context';
 import {
   type CredentialProcessor,
@@ -15,8 +15,9 @@ import {
   getCredentialAssertion,
 } from '@dxos/credentials';
 import { raise } from '@dxos/debug';
-import { type EchoHost, type SpaceManager } from '@dxos/echo-host';
+import { type EchoHost } from '@dxos/echo-host';
 import { type DatabaseDirectory } from '@dxos/echo-protocol';
+import { EffectEx } from '@dxos/effect';
 import { writeMessages } from '@dxos/feed-store';
 import { assertArgument, assertState, invariant } from '@dxos/invariant';
 import { SpaceId } from '@dxos/keys';
@@ -28,6 +29,7 @@ import {
   IdentityNotInitializedError,
   SpaceNotFoundError,
   encodeError,
+  makeInProcessClient,
 } from '@dxos/protocols';
 import {
   type AdmitContactRequest,
@@ -47,7 +49,6 @@ import {
   type Space,
   SpaceArchive,
   SpaceMember,
-  type SpacesService,
   SpaceState,
   type SubscribeMessagesRequest,
   type UpdateMemberRoleRequest,
@@ -56,10 +57,12 @@ import {
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
+import { FeedService, type SpacesService } from '@dxos/protocols/rpc';
 import { trace } from '@dxos/tracing';
 import { type Provider } from '@dxos/util';
 
 import { type IdentityManager } from '../identity';
+import { type SpaceManager } from '../space';
 import {
   SpaceArchiveWriter,
   detectSpaceArchiveFormat,
@@ -71,86 +74,102 @@ import {
 import { type DataSpace } from './data-space';
 import { type DataSpaceManager } from './data-space-manager';
 
-export class SpacesServiceImpl implements SpacesService {
-  constructor(
+export class SpacesServiceImpl implements SpacesService.Handlers {
+  'constructor'(
     private readonly _identityManager: IdentityManager,
     private readonly _spaceManager: SpaceManager,
     private readonly _echoHost: EchoHost,
     private readonly _getDataSpaceManager: Provider<Promise<DataSpaceManager>>,
   ) {}
 
-  async createSpace(request: CreateSpaceRequest, options?: RequestOptions): Promise<Space> {
-    this._requireIdentity();
-    const ctx = options?.ctx ?? new Context();
-    const dataSpaceManager = await this._getDataSpaceManager();
-    const space = await dataSpaceManager.createSpace(ctx, {
-      tags: request?.tags,
-      membershipPolicy: request?.membershipPolicy,
+  ['SpacesService.createSpace'](request: CreateSpaceRequest): Effect.Effect<Space, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        this._requireIdentity();
+        const ctx = new Context();
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const space = await dataSpaceManager.createSpace(ctx, {
+          tags: request?.tags,
+          membershipPolicy: request?.membershipPolicy,
+        });
+        await this._updateMetrics();
+        return this._serializeSpace(space);
+      },
+      catch: (error) => error as Error,
     });
-    await this._updateMetrics();
-    return this._serializeSpace(space);
   }
 
-  async updateSpace({ spaceKey, state, edgeReplication }: UpdateSpaceRequest, options?: RequestOptions): Promise<void> {
-    const ctx = options?.ctx ?? Context.default();
-    const dataSpaceManager = await this._getDataSpaceManager();
-    const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
-
-    if (state) {
-      switch (state) {
-        case SpaceState.SPACE_ACTIVE:
-          await space.activate(ctx);
-          break;
-
-        case SpaceState.SPACE_INACTIVE:
-          await space.deactivate(ctx);
-          break;
-
-        case SpaceState.SPACE_DELETED:
-          await dataSpaceManager.markSpaceDeleted(ctx, spaceKey);
-          // The space is removed from the manager; skip any further mutations (e.g. edgeReplication).
-          return;
-        default:
-          throw new ApiError({ message: 'Invalid space state' });
-      }
-    }
+  ['SpacesService.updateSpace']({ spaceKey, state, edgeReplication }: UpdateSpaceRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const ctx = Context.default();
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
 
-    if (edgeReplication !== undefined) {
-      await dataSpaceManager.setSpaceEdgeReplicationSetting(ctx, spaceKey, edgeReplication);
-    }
+        if (state) {
+          switch (state) {
+            case SpaceState.SPACE_ACTIVE:
+              await space.activate(ctx);
+              break;
+
+            case SpaceState.SPACE_INACTIVE:
+              await space.deactivate(ctx);
+              break;
+
+            case SpaceState.SPACE_DELETED:
+              await dataSpaceManager.markSpaceDeleted(ctx, spaceKey);
+              // The space is removed from the manager; skip any further mutations (e.g. edgeReplication).
+              return;
+            default:
+              throw new ApiError({ message: 'Invalid space state' });
+          }
+        }
+
+        if (edgeReplication !== undefined) {
+          await dataSpaceManager.setSpaceEdgeReplicationSetting(ctx, spaceKey, edgeReplication);
+        }
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async updateMemberRole(request: UpdateMemberRoleRequest): Promise<void> {
-    const identity = this._requireIdentity();
-    const space = this._spaceManager.spaces.get(request.spaceKey);
-    if (space == null) {
-      throw new SpaceNotFoundError(request.spaceKey);
-    }
-    if (!space.spaceState.hasMembershipManagementPermission(identity.identityKey)) {
-      throw new AuthorizationError({
-        message: 'No member management permission.',
-        context: {
-          spaceKey: space.key,
-          role: space.spaceState.getMemberRole(identity.identityKey),
-        },
-      });
-    }
-    const credentials = await createAdmissionCredentials(
-      identity.getIdentityCredentialSigner(),
-      request.memberKey,
-      space.key,
-      space.genesisFeedKey,
-      request.newRole,
-      space.spaceState.membershipChainHeads,
-    );
-    invariant(credentials[0].credential);
-    const spaceMemberCredential = credentials[0].credential.credential;
-    invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
-    await writeMessages(space.controlPipeline.writer, credentials);
+  ['SpacesService.updateMemberRole'](request: UpdateMemberRoleRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const identity = this._requireIdentity();
+        const space = this._spaceManager.spaces.get(request.spaceKey);
+        if (space == null) {
+          throw new SpaceNotFoundError(request.spaceKey);
+        }
+        if (!space.spaceState.hasMembershipManagementPermission(identity.identityKey)) {
+          throw new AuthorizationError({
+            message: 'No member management permission.',
+            context: {
+              spaceKey: space.key,
+              role: space.spaceState.getMemberRole(identity.identityKey),
+            },
+          });
+        }
+        const credentials = await createAdmissionCredentials(
+          identity.getIdentityCredentialSigner(),
+          request.memberKey,
+          space.key,
+          space.genesisFeedKey,
+          request.newRole,
+          space.spaceState.membershipChainHeads,
+        );
+        invariant(credentials[0].credential);
+        const spaceMemberCredential = credentials[0].credential.credential;
+        invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+        await writeMessages(space.controlPipeline.writer, credentials);
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  querySpaces(): Stream<QuerySpacesResponse> {
-    return new Stream<QuerySpacesResponse>(({ next, ctx }) => {
+  ['SpacesService.querySpaces'](): EffectStream.Stream<QuerySpacesResponse, Error> {
+    return EffectStream.async<QuerySpacesResponse, Error>((emit) => {
+      const ctx = Context.default();
       const scheduler = new UpdateScheduler(
         ctx,
         async () => {
@@ -160,7 +179,7 @@ export class SpacesServiceImpl implements SpacesService {
           );
           log('update', () => ({ ids: spaces.map((space) => space.id) }));
           await this._updateMetrics();
-          next({ spaces });
+          void emit.single({ spaces });
         },
         { maxFrequency: process.env.NODE_ENV === 'test' ? undefined : 2 },
       );
@@ -207,163 +226,216 @@ export class SpacesServiceImpl implements SpacesService {
       });
 
       if (!this._identityManager.identity) {
-        next({ spaces: [] });
+        void emit.single({ spaces: [] });
       }
+
+      return Effect.promise(() => ctx.dispose());
     });
   }
 
-  async postMessage({ spaceKey, channel, message }: PostMessageRequest): Promise<void> {
-    const dataSpaceManager = await this._getDataSpaceManager();
-    const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
-    await space.postMessage(getChannelId(channel), message);
+  ['SpacesService.postMessage']({ spaceKey, channel, message }: PostMessageRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+        await space.postMessage(getChannelId(channel), message);
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  subscribeMessages({ spaceKey, channel }: SubscribeMessagesRequest): Stream<GossipMessage> {
-    return new Stream<GossipMessage>(({ ctx, next }) => {
+  ['SpacesService.subscribeMessages']({
+    spaceKey,
+    channel,
+  }: SubscribeMessagesRequest): EffectStream.Stream<GossipMessage, Error> {
+    return EffectStream.async<GossipMessage, Error>((emit) => {
+      const ctx = Context.default();
       scheduleTask(ctx, async () => {
         const dataSpaceManager = await this._getDataSpaceManager();
         const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
         const handle = space.listen(getChannelId(channel), (message) => {
-          next(message);
+          void emit.single(message);
         });
         ctx.onDispose(() => handle.unsubscribe());
       });
+
+      return Effect.promise(() => ctx.dispose());
     });
   }
 
-  queryCredentials({ spaceKey, noTail }: QueryCredentialsRequest): Stream<Credential> {
-    return new Stream(({ ctx, next, close }) => {
+  ['SpacesService.queryCredentials']({
+    spaceKey,
+    noTail,
+  }: QueryCredentialsRequest): EffectStream.Stream<Credential, Error> {
+    return EffectStream.async<Credential, Error>((emit) => {
+      const ctx = Context.default();
       const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
 
       const processor: CredentialProcessor = {
         processCredential: async (credential) => {
-          next(credential);
+          void emit.single(credential);
         },
       };
       ctx.onDispose(() => space.spaceState.removeCredentialProcessor(processor));
       scheduleTask(ctx, async () => {
         await space.spaceState.addCredentialProcessor(processor);
         if (noTail) {
-          close();
+          void emit.end();
         }
       });
+
+      return Effect.promise(() => ctx.dispose());
     });
   }
 
-  async writeCredentials({ spaceKey, credentials }: WriteCredentialsRequest): Promise<void> {
-    const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
-    for (const credential of credentials ?? []) {
-      if (credential.proof) {
-        await space.controlPipeline.writer.write({ credential: { credential } });
-      } else {
-        invariant(!credential.id, 'Id on unsigned credentials is not allowed');
-        invariant(this._identityManager.identity, 'Identity is not available');
-        const signer = this._identityManager.identity.getIdentityCredentialSigner();
-        invariant(credential.issuer.equals(signer.getIssuer()));
-        const signedCredential = await signer.createCredential({
-          subject: credential.subject.id,
-          assertion: credential.subject.assertion,
-        });
-        await space.controlPipeline.writer.write({ credential: { credential: signedCredential } });
-      }
-    }
+  ['SpacesService.writeCredentials']({ spaceKey, credentials }: WriteCredentialsRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const space = this._spaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+        for (const credential of credentials ?? []) {
+          if (credential.proof) {
+            await space.controlPipeline.writer.write({ credential: { credential } });
+          } else {
+            invariant(!credential.id, 'Id on unsigned credentials is not allowed');
+            invariant(this._identityManager.identity, 'Identity is not available');
+            const signer = this._identityManager.identity.getIdentityCredentialSigner();
+            invariant(credential.issuer.equals(signer.getIssuer()));
+            const signedCredential = await signer.createCredential({
+              subject: credential.subject.id,
+              assertion: credential.subject.assertion,
+            });
+            await space.controlPipeline.writer.write({ credential: { credential: signedCredential } });
+          }
+        }
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async createEpoch({ spaceKey, migration, automergeRootUrl }: CreateEpochRequest): Promise<CreateEpochResponse> {
-    const dataSpaceManager = await this._getDataSpaceManager();
-    const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
-    const result = await space.createEpoch({ migration, newAutomergeRoot: automergeRootUrl });
-    return { epochCredential: result?.credential, controlTimeframe: result?.timeframe };
+  ['SpacesService.createEpoch']({
+    spaceKey,
+    migration,
+    automergeRootUrl,
+  }: CreateEpochRequest): Effect.Effect<CreateEpochResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const space = dataSpaceManager.spaces.get(spaceKey) ?? raise(new SpaceNotFoundError(spaceKey));
+        const result = await space.createEpoch({ migration, newAutomergeRoot: automergeRootUrl });
+        return { epochCredential: result?.credential, controlTimeframe: result?.timeframe };
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async admitContact(request: AdmitContactRequest): Promise<void> {
-    const dataSpaceManager = await this._getDataSpaceManager();
-    await dataSpaceManager.admitMember({
-      spaceKey: request.spaceKey,
-      identityKey: request.contact.identityKey,
-      role: request.role,
+  ['SpacesService.admitContact'](request: AdmitContactRequest): Effect.Effect<void, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const dataSpaceManager = await this._getDataSpaceManager();
+        await dataSpaceManager.admitMember({
+          spaceKey: request.spaceKey,
+          identityKey: request.contact.identityKey,
+          role: request.role,
+        });
+      },
+      catch: (error) => error as Error,
     });
   }
 
-  async joinBySpaceKey({ spaceKey }: JoinBySpaceKeyRequest, options?: RequestOptions): Promise<JoinSpaceResponse> {
-    const ctx = options?.ctx ?? Context.default();
-    const dataSpaceManager = await this._getDataSpaceManager();
-    const credential = await dataSpaceManager.requestSpaceAdmissionCredential(ctx, spaceKey);
-    return this._joinByAdmission(ctx, { credential });
+  ['SpacesService.joinBySpaceKey']({ spaceKey }: JoinBySpaceKeyRequest): Effect.Effect<JoinSpaceResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const ctx = Context.default();
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const credential = await dataSpaceManager.requestSpaceAdmissionCredential(ctx, spaceKey);
+        return this._joinByAdmission(ctx, { credential });
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async exportSpace(request: ExportSpaceRequest): Promise<ExportSpaceResponse> {
-    assertArgument(SpaceId.isValid(request.spaceId), 'spaceId', 'Invalid space ID');
+  ['SpacesService.exportSpace'](request: ExportSpaceRequest): Effect.Effect<ExportSpaceResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        assertArgument(SpaceId.isValid(request.spaceId), 'spaceId', 'Invalid space ID');
 
-    const dataSpaceManager = await this._getDataSpaceManager();
-    const space = dataSpaceManager.getSpaceById(request.spaceId) ?? raise(new Error('Space not found'));
+        const dataSpaceManager = await this._getDataSpaceManager();
+        const space = dataSpaceManager.getSpaceById(request.spaceId) ?? raise(new Error('Space not found'));
 
-    const format = request.format ?? SpaceArchive.Format.BINARY;
-    if (format === SpaceArchive.Format.JSON) {
-      const archive = await writeSerializedSpaceArchive({ space, echoHost: this._echoHost });
-      return { archive };
-    }
+        const format = request.format ?? SpaceArchive.Format.BINARY;
+        if (format === SpaceArchive.Format.JSON) {
+          const archive = await writeSerializedSpaceArchive({ space, echoHost: this._echoHost });
+          return { archive };
+        }
 
-    await using writer = await new SpaceArchiveWriter().open();
-    await writer.begin({ spaceId: space.id });
-    const rootUrl = space.automergeSpaceState.lastEpoch?.subject.assertion.automergeRoot;
-    assertState(rootUrl, 'Space does not have a root URL');
-    await writer.setCurrentRootUrl(rootUrl);
+        await using writer = await new SpaceArchiveWriter().open();
+        await writer.begin({ spaceId: space.id });
+        const rootUrl = space.automergeSpaceState.lastEpoch?.subject.assertion.automergeRoot;
+        assertState(rootUrl, 'Space does not have a root URL');
+        await writer.setCurrentRootUrl(rootUrl);
 
-    for await (const [documentId, data] of space.getAllDocuments()) {
-      await writer.writeDocument(documentId, data);
-    }
+        for await (const [documentId, data] of space.getAllDocuments()) {
+          await writer.writeDocument(documentId, data);
+        }
 
-    const feeds = await space.getAllFeeds();
-    for (const feed of feeds) {
-      const archiveBlocks = feed.blocks.map((block) => ({
-        actorId: block.actorId,
-        sequence: block.sequence,
-        prevActorId: block.prevActorId,
-        prevSequence: block.prevSequence,
-        position: block.position,
-        timestamp: block.timestamp,
-        data: Buffer.from(block.data).toString('base64'),
-      }));
-      await writer.writeFeed(feed.feedId, feed.feedNamespace, archiveBlocks);
-    }
+        const feeds = await space.getAllFeeds();
+        for (const feed of feeds) {
+          const archiveBlocks = feed.blocks.map((block) => ({
+            actorId: block.actorId,
+            sequence: block.sequence,
+            prevActorId: block.prevActorId,
+            prevSequence: block.prevSequence,
+            position: block.position,
+            timestamp: block.timestamp,
+            data: Buffer.from(block.data).toString('base64'),
+          }));
+          await writer.writeFeed(feed.feedId, feed.feedNamespace, archiveBlocks);
+        }
 
-    const archive = await writer.finish();
-    return { archive };
+        const archive = await writer.finish();
+        return { archive };
+      },
+      catch: (error) => error as Error,
+    });
   }
 
-  async importSpace(request: ImportSpaceRequest, options?: RequestOptions): Promise<ImportSpaceResponse> {
-    const ctx = options?.ctx ?? Context.default();
-    const dataSpaceManager = await this._getDataSpaceManager();
+  ['SpacesService.importSpace'](request: ImportSpaceRequest): Effect.Effect<ImportSpaceResponse, Error> {
+    return Effect.tryPromise({
+      try: async () => {
+        const ctx = Context.default();
+        const dataSpaceManager = await this._getDataSpaceManager();
 
-    const format = request.archive.format ?? detectSpaceArchiveFormat(request.archive);
-    if (format === SpaceArchive.Format.JSON) {
-      const serialized = readSerializedSpaceArchive(request.archive);
-      const space = await dataSpaceManager.createSpace(ctx, { tags: request.tags });
-      await this._hydrateSpaceFromSerialized(space, serialized);
-      await this._updateMetrics();
-      return { newSpaceId: space.id };
-    }
+        const format = request.archive.format ?? detectSpaceArchiveFormat(request.archive);
+        if (format === SpaceArchive.Format.JSON) {
+          const serialized = readSerializedSpaceArchive(request.archive);
+          const space = await dataSpaceManager.createSpace(ctx, { tags: request.tags });
+          await this._hydrateSpaceFromSerialized(space, serialized);
+          await this._updateMetrics();
+          return { newSpaceId: space.id };
+        }
 
-    const extracted = await extractSpaceArchive(request.archive);
-    invariant(extracted.metadata.echo?.currentRootUrl, 'Space archive does not contain a root URL');
-    const space = await dataSpaceManager.createSpace(ctx, {
-      documents: extracted.documents,
-      rootUrl: extracted.metadata.echo?.currentRootUrl as AutomergeUrl,
-      tags: request.tags,
+        const extracted = await extractSpaceArchive(request.archive);
+        invariant(extracted.metadata.echo?.currentRootUrl, 'Space archive does not contain a root URL');
+        const space = await dataSpaceManager.createSpace(ctx, {
+          documents: extracted.documents,
+          rootUrl: extracted.metadata.echo?.currentRootUrl as AutomergeUrl,
+          tags: request.tags,
+        });
+        await this._updateMetrics();
+        return { newSpaceId: space.id };
+      },
+      catch: (error) => error as Error,
     });
-    await this._updateMetrics();
-    return { newSpaceId: space.id };
   }
 
   /**
    * Populate a freshly-created space with the objects and feed messages described in a {@link SerializedSpace}.
    *
    * Objects are written directly into the space's automerge root document as inline
-   * {@link EntityStructure} entries; feed messages are appended to the appropriate queue
-   * via {@link EchoHost.queuesService}.
+   * {@link EntityStructure} entries; feed messages are appended to the appropriate feed
+   * via {@link EchoHost.feedService}.
    */
-  private async _hydrateSpaceFromSerialized(
+  private async '_hydrateSpaceFromSerialized'(
     space: DataSpace,
     serialized: ReturnType<typeof readSerializedSpaceArchive>,
   ): Promise<void> {
@@ -387,19 +459,26 @@ export class SpacesServiceImpl implements SpacesService {
       const namespace =
         feed.namespace === 'trace' ? FeedProtocol.WellKnownNamespaces.trace : FeedProtocol.WellKnownNamespaces.data;
       try {
-        await this._echoHost.queuesService.insertIntoQueue({
-          spaceId: space.id,
-          queueId: feed.feedObjectId,
-          subspaceTag: namespace,
-          objects: feed.messages.map((message) => JSON.stringify(message)),
-        });
+        // Handlers are served, not called directly; bridge to a client in-process for this write.
+        const feedService = this._echoHost.feedService;
+        await EffectEx.runPromise(
+          Effect.gen(function* () {
+            const feedClient = yield* makeInProcessClient(FeedService.Rpcs, feedService);
+            yield* feedClient.FeedService.insertIntoFeed({
+              spaceId: space.id,
+              feedId: feed.feedObjectId,
+              subspaceTag: namespace,
+              objects: feed.messages.map((message) => JSON.stringify(message)),
+            });
+          }).pipe(Effect.scoped),
+        );
       } catch (err) {
         log.warn('failed to import feed data', { feedObjectId: feed.feedObjectId, error: err });
       }
     }
   }
 
-  private async _joinByAdmission(ctx: Context, { credential }: ContactAdmission): Promise<JoinSpaceResponse> {
+  private async '_joinByAdmission'(ctx: Context, { credential }: ContactAdmission): Promise<JoinSpaceResponse> {
     const assertion = getCredentialAssertion(credential);
     invariant(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
     const myIdentity = this._identityManager.identity;
@@ -419,7 +498,7 @@ export class SpacesServiceImpl implements SpacesService {
     return { space: await this._serializeSpace(dataSpace) };
   }
 
-  private async _serializeSpace(space: DataSpace): Promise<Space> {
+  private async '_serializeSpace'(space: DataSpace): Promise<Space> {
     return {
       id: space.id,
       spaceKey: space.key,
@@ -472,7 +551,7 @@ export class SpacesServiceImpl implements SpacesService {
     };
   }
 
-  private _requireIdentity() {
+  private '_requireIdentity'() {
     if (!this._identityManager.identity) {
       throw new IdentityNotInitializedError({
         message: 'This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo',
@@ -481,7 +560,7 @@ export class SpacesServiceImpl implements SpacesService {
     return this._identityManager.identity;
   }
 
-  private async _updateMetrics(): Promise<void> {
+  private async '_updateMetrics'(): Promise<void> {
     const dataSpaceManager = await this._getDataSpaceManager();
     const identity = this._identityManager.identity?.identityKey.truncate();
     if (identity) {

package/src/packlets/storage/level.ts

@@ -5,12 +5,14 @@
 import path from 'node:path';
 
 import { PublicKey } from '@dxos/keys';
-import { createLevel as createKV } from '@dxos/kv-store';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 
 import { getRootPath, isPersistent } from './util';
 
 export const createLevel = async (config: Runtime.Client.Storage) => {
+  // Imported here rather than at module scope so that this barrel, which the client pulls in on every
+  // startup, does not bind `level`'s native addon — a compiled binary cannot carry one.
+  const { createLevel: createKV } = await import('@dxos/kv-store/level');
   const persistent = isPersistent(config);
   const storagePath = persistent ? path.join(getRootPath(config), 'level') : `/tmp/dxos-${PublicKey.random().toHex()}`;
   const level = createKV(storagePath);