@dxos/client-services 0.1.53 → 0.1.54-main.270ec56

package/src/packlets/identity/identity.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { Event } from '@dxos/async';
 import { AUTH_TIMEOUT, LOAD_CONTROL_FEEDS_TIMEOUT } from '@dxos/client-protocol';
@@ -12,7 +12,6 @@ import {
   createCredentialSignerWithKey,
   createCredentialSignerWithChain,
   ProfileStateMachine,
-  CredentialConsumer,
 } from '@dxos/credentials';
 import { Signer } from '@dxos/crypto';
 import { failUndefined } from '@dxos/debug';
@@ -40,8 +39,8 @@ export type IdentityParams = {
 export class Identity {
   public readonly space: Space;
   private readonly _signer: Signer;
-  private readonly _deviceStateMachine: CredentialConsumer<DeviceStateMachine>;
-  private readonly _profileStateMachine: CredentialConsumer<ProfileStateMachine>;
+  private readonly _deviceStateMachine: DeviceStateMachine;
+  private readonly _profileStateMachine: ProfileStateMachine;
   public readonly authVerifier: TrustedKeySetAuthVerifier;
 
   public readonly identityKey: PublicKey;
@@ -56,19 +55,15 @@ export class Identity {
     this.identityKey = identityKey;
     this.deviceKey = deviceKey;
 
-    this._deviceStateMachine = this.space.spaceState.registerProcessor(
-      new DeviceStateMachine({
-        identityKey: this.identityKey,
-        deviceKey: this.deviceKey,
-        onUpdate: () => this.stateUpdate.emit(),
-      }),
-    );
-    this._profileStateMachine = this.space.spaceState.registerProcessor(
-      new ProfileStateMachine({
-        identityKey: this.identityKey,
-        onUpdate: () => this.stateUpdate.emit(),
-      }),
-    );
+    this._deviceStateMachine = new DeviceStateMachine({
+      identityKey: this.identityKey,
+      deviceKey: this.deviceKey,
+      onUpdate: () => this.stateUpdate.emit(),
+    });
+    this._profileStateMachine = new ProfileStateMachine({
+      identityKey: this.identityKey,
+      onUpdate: () => this.stateUpdate.emit(),
+    });
 
     this.authVerifier = new TrustedKeySetAuthVerifier({
       trustedKeysProvider: () => this.authorizedDeviceKeys,
@@ -79,30 +74,30 @@ export class Identity {
 
   // TODO(burdon): Expose state object?
   get authorizedDeviceKeys(): ComplexSet<PublicKey> {
-    return this._deviceStateMachine.processor.authorizedDeviceKeys;
+    return this._deviceStateMachine.authorizedDeviceKeys;
   }
 
   async open() {
-    await this._deviceStateMachine.open();
-    await this._profileStateMachine.open();
+    await this.space.spaceState.addCredentialProcessor(this._deviceStateMachine);
+    await this.space.spaceState.addCredentialProcessor(this._profileStateMachine);
     await this.space.open();
   }
 
   async close() {
     await this.authVerifier.close();
-    await this._deviceStateMachine.close();
-    await this._profileStateMachine.close();
+    await this.space.spaceState.removeCredentialProcessor(this._profileStateMachine);
+    await this.space.spaceState.removeCredentialProcessor(this._deviceStateMachine);
     await this.space.close();
   }
 
   async ready() {
-    await this._deviceStateMachine.processor.deviceChainReady.wait();
+    await this._deviceStateMachine.deviceChainReady.wait();
 
     await this.controlPipeline.state.waitUntilReachedTargetTimeframe({ timeout: LOAD_CONTROL_FEEDS_TIMEOUT });
   }
 
   get profileDocument(): ProfileDocument | undefined {
-    return this._profileStateMachine.processor.profile;
+    return this._profileStateMachine.profile;
   }
 
   /**
@@ -121,7 +116,7 @@ export class Identity {
   }
 
   get deviceCredentialChain() {
-    return this._deviceStateMachine.processor.deviceCredentialChain;
+    return this._deviceStateMachine.deviceCredentialChain;
   }
 
   getAdmissionCredentials(): DeviceAdmissionRequest {
@@ -137,10 +132,10 @@ export class Identity {
    * Requires identity to be ready.
    */
   getIdentityCredentialSigner(): CredentialSigner {
-    assert(this._deviceStateMachine.processor.deviceCredentialChain, 'Device credential chain is not ready.');
+    invariant(this._deviceStateMachine.deviceCredentialChain, 'Device credential chain is not ready.');
     return createCredentialSignerWithChain(
       this._signer,
-      this._deviceStateMachine.processor.deviceCredentialChain,
+      this._deviceStateMachine.deviceCredentialChain,
       this.deviceKey,
     );
   }

package/src/packlets/invitations/device-invitation-protocol.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { Keyring } from '@dxos/keyring';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
@@ -29,7 +29,7 @@ export class DeviceInvitationProtocol implements InvitationProtocol {
   }
 
   async admit(request: AdmissionRequest): Promise<AdmissionResponse> {
-    assert(request.device);
+    invariant(request.device);
     const identity = this._getIdentity();
     await identity.admitDevice(request.device);
 
@@ -62,10 +62,10 @@ export class DeviceInvitationProtocol implements InvitationProtocol {
   }
 
   async accept(response: AdmissionResponse, request: AdmissionRequest): Promise<Partial<Invitation>> {
-    assert(response.device);
+    invariant(response.device);
     const { identityKey, haloSpaceKey, genesisFeedKey, controlTimeframe } = response.device;
 
-    assert(request.device);
+    invariant(request.device);
     const { deviceKey, controlFeedKey, dataFeedKey } = request.device;
 
     await this._acceptIdentity({

package/src/packlets/invitations/invitation-extension.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { Trigger } from '@dxos/async';
 import { cancelWithContext, Context } from '@dxos/context';
@@ -86,7 +86,7 @@ export class InvitationHostExtension extends RpcExtension<
       // Perhaps in the future we will have more complex logic here.
       InvitationHostService: {
         options: async (options) => {
-          assert(!this._remoteOptions, 'Remote options already set.');
+          invariant(!this._remoteOptions, 'Remote options already set.');
           this._remoteOptions = options;
           this._remoteOptionsTrigger.wake();
         },
@@ -128,7 +128,7 @@ export class InvitationHostExtension extends RpcExtension<
           log('received authentication request', { authCode: code });
           let status = AuthenticationResponse.Status.OK;
 
-          assert(this.invitation, 'Invitation is not set.');
+          invariant(this.invitation, 'Invitation is not set.');
           switch (this.invitation.authMethod) {
             case Invitation.AuthMethod.NONE: {
               log('authentication not required');
@@ -164,7 +164,7 @@ export class InvitationHostExtension extends RpcExtension<
           log.trace('dxos.sdk.invitation-handler.host.admit', trace.begin({ id: traceId }));
 
           try {
-            assert(this.invitation, 'Invitation is not set.');
+            invariant(this.invitation, 'Invitation is not set.');
             // Check authenticated.
             if (isAuthenticationRequired(this.invitation) && !this.authenticationPassed) {
               throw new Error('Not authenticated');
@@ -239,7 +239,7 @@ export class InvitationGuestExtension extends RpcExtension<
     return {
       InvitationHostService: {
         options: async (options) => {
-          assert(!this._remoteOptions, 'Remote options already set.');
+          invariant(!this._remoteOptions, 'Remote options already set.');
           this._remoteOptions = options;
           this._remoteOptionsTrigger.wake();
         },

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

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { PushStream, scheduleTask, TimeoutError, Trigger } from '@dxos/async';
 import {
@@ -74,7 +74,7 @@ export class InvitationsHandler {
     const authCode =
       options?.authCode ??
       (authMethod === Invitation.AuthMethod.SHARED_SECRET ? generatePasscode(AUTHENTICATION_CODE_LENGTH) : undefined);
-    assert(protocol);
+    invariant(protocol);
 
     const invitation: Invitation = {
       invitationId,
@@ -117,7 +117,7 @@ export class InvitationsHandler {
         admit: async (admissionRequest) => {
           try {
             const deviceKey = admissionRequest.device?.deviceKey ?? admissionRequest.space?.deviceKey;
-            assert(deviceKey);
+            invariant(deviceKey);
             const admissionResponse = await protocol.admit(admissionRequest, extension.guestProfile);
 
             // Updating credentials complete.
@@ -208,7 +208,7 @@ export class InvitationsHandler {
 
   acceptInvitation(protocol: InvitationProtocol, invitation: Invitation): AuthenticatingInvitationObservable {
     const { timeout = INVITATION_TIMEOUT } = invitation;
-    assert(protocol);
+    invariant(protocol);
 
     const authenticated = new Trigger<string>();
 
@@ -219,7 +219,7 @@ export class InvitationsHandler {
     let currentState: Invitation.State;
     const stream = new PushStream<Invitation>();
     const setState = (newData: Partial<Invitation>) => {
-      assert(newData.state !== undefined);
+      invariant(newData.state !== undefined);
       currentState = newData.state;
       stream.next({ ...invitation, ...newData });
     };
@@ -354,7 +354,7 @@ export class InvitationsHandler {
     };
 
     scheduleTask(ctx, async () => {
-      assert(invitation.swarmKey);
+      invariant(invitation.swarmKey);
       const topic = invitation.swarmKey;
       const swarmConnection = await this._networkManager.joinSwarm({
         topic,

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

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { Event } from '@dxos/async';
 import { AuthenticatingInvitationObservable, CancellableInvitationObservable } from '@dxos/client-protocol';
@@ -101,7 +101,7 @@ export class InvitationsServiceImpl implements InvitationsService {
 
   async authenticate({ invitationId, authCode }: AuthenticationRequest): Promise<void> {
     log('authenticating...');
-    assert(invitationId);
+    invariant(invitationId);
     const observable = this._acceptInvitations.get(invitationId);
     if (!observable) {
       log.warn('invalid invitation', { invitationId });
@@ -112,7 +112,7 @@ export class InvitationsServiceImpl implements InvitationsService {
 
   async cancelInvitation({ invitationId }: { invitationId: string }): Promise<void> {
     log('deleting...');
-    assert(invitationId);
+    invariant(invitationId);
     const created = this._createInvitations.get(invitationId);
     const accepted = this._acceptInvitations.get(invitationId);
     if (created) {

package/src/packlets/invitations/space-invitation-protocol.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { createAdmissionCredentials, getCredentialAssertion } from '@dxos/credentials';
 import { writeMessages } from '@dxos/feed-store';
@@ -40,11 +40,11 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
   }
 
   async admit(request: AdmissionRequest, guestProfile?: ProfileDocument | undefined): Promise<AdmissionResponse> {
-    assert(this._spaceKey);
+    invariant(this._spaceKey);
     const space = await this._spaceManager.spaces.get(this._spaceKey);
-    assert(space);
+    invariant(space);
 
-    assert(request.space);
+    invariant(request.space);
     const { identityKey, deviceKey } = request.space;
 
     log('writing guest credentials', { host: this._signingContext.deviceKey, guest: deviceKey });
@@ -58,9 +58,9 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
     );
 
     // TODO(dmaretskyi): Refactor.
-    assert(credentials[0].credential);
+    invariant(credentials[0].credential);
     const spaceMemberCredential = credentials[0].credential.credential;
-    assert(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
+    invariant(getCredentialAssertion(spaceMemberCredential)['@type'] === 'dxos.halo.credentials.SpaceMember');
 
     await writeMessages(space.inner.controlPipeline.writer, credentials);
 
@@ -95,11 +95,11 @@ export class SpaceInvitationProtocol implements InvitationProtocol {
   }
 
   async accept(response: AdmissionResponse): Promise<Partial<Invitation>> {
-    assert(response.space);
+    invariant(response.space);
     const { credential, controlTimeframe, dataTimeframe } = response.space;
     const assertion = getCredentialAssertion(credential);
-    assert(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
-    assert(credential.subject.id.equals(this._signingContext.identityKey));
+    invariant(assertion['@type'] === 'dxos.halo.credentials.SpaceMember', 'Invalid credential');
+    invariant(credential.subject.id.equals(this._signingContext.identityKey));
 
     // Create local space.
     await this._spaceManager.acceptSpace({

package/src/packlets/locks/node.ts

@@ -2,8 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-import assert from 'node:assert';
 import { FileHandle } from 'node:fs/promises';
+import invariant from 'tiny-invariant';
 
 import { LockFile } from '@dxos/lock-file';
 import { log, logInfo } from '@dxos/log';
@@ -39,7 +39,7 @@ export class Lock implements ResourceLock {
 
   async release() {
     await this._onRelease?.();
-    assert(this._fileHandle, 'Lock is not acquired');
+    invariant(this._fileHandle, 'Lock is not acquired');
     await LockFile.release(this._fileHandle);
   }
 }

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

@@ -33,7 +33,7 @@ export class LoggingServiceImpl implements LoggingService {
 
         // Prevent logging feedback loop from logging service.
         if (
-          entry.meta?.file.includes('logging-service') ||
+          entry.meta?.F.includes('logging-service') ||
           (entry.context &&
             Object.values(entry.context).some((value) => typeof value === 'string' && value.includes('LoggingService')))
         ) {
@@ -50,8 +50,8 @@ export class LoggingServiceImpl implements LoggingService {
           timestamp: new Date(),
           meta: {
             // TODO(dmaretskyi): Fix proto.
-            file: entry.meta?.file ?? '',
-            line: entry.meta?.line ?? 0,
+            file: entry.meta?.F ?? '',
+            line: entry.meta?.L ?? 0,
           },
         };
 
@@ -94,7 +94,7 @@ const shouldLog = (entry: NaturalLogEntry, request: QueryLogsRequest): boolean =
   if (request.filters === undefined) {
     return options === QueryLogsRequest.MatchingOptions.INCLUSIVE;
   } else {
-    return request.filters.some((filter) => matchFilter(filter, entry.level, entry.meta?.file ?? '', options));
+    return request.filters.some((filter) => matchFilter(filter, entry.level, entry.meta?.F ?? '', options));
   }
 };
 

package/src/packlets/services/index.ts

@@ -2,6 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
+export * from './client-rpc-server';
 export * from './service-context';
 export * from './service-host';
 export * from './service-registry';

package/src/packlets/services/service-context.test.ts

@@ -36,7 +36,7 @@ describe('services/ServiceContext', () => {
     await device2.dataSpaceManager!.waitUntilSpaceReady(space1!.key);
     const space2 = await device2.dataSpaceManager!.spaces.get(space1.key);
     await syncItemsLocal(space1.dataPipeline, space2!.dataPipeline);
-  });
+  }).tag('flaky');
 
   test('joined space is synchronized on device invitations', async () => {
     const networkContext = new MemorySignalManagerContext();

package/src/packlets/services/service-context.ts

@@ -2,10 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { Trigger } from '@dxos/async';
-import { CredentialConsumer, getCredentialAssertion } from '@dxos/credentials';
+import { CredentialProcessor, getCredentialAssertion } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import {
   valueEncoding,
@@ -64,7 +64,7 @@ export class ServiceContext {
     (invitation: Partial<Invitation>) => InvitationProtocol
   >();
 
-  private _deviceSpaceSync?: CredentialConsumer<any>;
+  private _deviceSpaceSync?: CredentialProcessor;
 
   private readonly _instanceId = PublicKey.random().toHex();
 
@@ -141,7 +141,9 @@ export class ServiceContext {
 
   async close() {
     log('closing...');
-    await this._deviceSpaceSync?.close();
+    if (this._deviceSpaceSync && this.identityManager.identity) {
+      await this.identityManager.identity.space.spaceState.removeCredentialProcessor(this._deviceSpaceSync);
+    }
     await this.dataSpaceManager?.close();
     await this.identityManager.close();
     await this.spaceManager.close();
@@ -161,7 +163,7 @@ export class ServiceContext {
 
   getInvitationHandler(invitation: Partial<Invitation> & Pick<Invitation, 'kind'>): InvitationProtocol {
     const factory = this._handlerFactories.get(invitation.kind);
-    assert(factory, `Unknown invitation kind: ${invitation.kind}`);
+    invariant(factory, `Unknown invitation kind: ${invitation.kind}`);
     return factory(invitation);
   }
 
@@ -205,13 +207,13 @@ export class ServiceContext {
     await this.dataSpaceManager.open();
 
     this._handlerFactories.set(Invitation.Kind.SPACE, (invitation) => {
-      assert(this.dataSpaceManager, 'dataSpaceManager not initialized yet');
+      invariant(this.dataSpaceManager, 'dataSpaceManager not initialized yet');
       return new SpaceInvitationProtocol(this.dataSpaceManager, signingContext, this.keyring, invitation.spaceKey);
     });
     this.initialized.wake();
 
-    this._deviceSpaceSync = identity.space.spaceState.registerProcessor({
-      process: async (credential: Credential) => {
+    this._deviceSpaceSync = {
+      processCredential: async (credential: Credential) => {
         const assertion = getCredentialAssertion(credential);
         if (assertion['@type'] !== 'dxos.halo.credentials.SpaceMember') {
           return;
@@ -239,7 +241,7 @@ export class ServiceContext {
           log.catch(err);
         }
       },
-    });
-    await this._deviceSpaceSync.open();
+    };
+    await identity.space.spaceState.addCredentialProcessor(this._deviceSpaceSync);
   }
 }

package/src/packlets/services/service-host.test.ts

@@ -2,19 +2,32 @@
 // Copyright 2023 DXOS.org
 //
 
-import { expect } from 'chai';
+import chai, { expect } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import { rmSync } from 'node:fs';
 
-import { latch, Trigger } from '@dxos/async';
+import { asyncTimeout, latch, Trigger } from '@dxos/async';
 import { Config } from '@dxos/config';
 import { verifyPresentation } from '@dxos/credentials';
 import { PublicKey } from '@dxos/keys';
 import { MemorySignalManagerContext } from '@dxos/messaging';
+import { Identity } from '@dxos/protocols/proto/dxos/client/services';
 import { Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { afterTest, describe, test } from '@dxos/test';
+import { isNode } from '@dxos/util';
 
 import { createMockCredential, createServiceHost } from '../testing';
 
+chai.use(chaiAsPromised);
+
 describe('ClientServicesHost', () => {
+  const persistentStoragePath = '/tmp/dxos/client-services/service-host/storage';
+
+  afterEach(async () => {
+    // Clean up.
+    isNode() && rmSync(persistentStoragePath, { recursive: true, force: true });
+  });
+
   test('queryCredentials', async () => {
     const host = createServiceHost(new Config(), new MemorySignalManagerContext());
     await host.open();
@@ -97,4 +110,39 @@ describe('ClientServicesHost', () => {
       kind: 'pass',
     });
   });
+
+  test('storage reset', async () => {
+    const config = new Config({
+      runtime: { client: { storage: { persistent: true, path: persistentStoragePath } } },
+    });
+    {
+      const host = createServiceHost(config, new MemorySignalManagerContext());
+      await host.open();
+
+      await host.services.IdentityService?.createIdentity({});
+
+      expect(host._serviceContext.storage.size).to.exist;
+
+      await asyncTimeout(host.reset(), 1000);
+      await host.close();
+    }
+
+    {
+      const host = createServiceHost(config, new MemorySignalManagerContext());
+      await host.open();
+      const trigger = new Trigger<Identity>();
+
+      const stream = host.services.IdentityService?.queryIdentity();
+      await stream?.waitUntilReady();
+
+      stream?.subscribe((identity) => {
+        if (identity.identity) {
+          trigger.wake(identity.identity);
+        }
+      });
+      await expect(asyncTimeout(trigger.wait(), 200)).to.be.rejectedWith();
+      stream?.close();
+      await host.close();
+    }
+  }).onlyEnvironments('nodejs', 'chromium', 'firefox');
 });

package/src/packlets/services/service-host.ts

@@ -2,11 +2,12 @@
 // Copyright 2021 DXOS.org
 //
 
-import assert from 'node:assert';
+import invariant from 'tiny-invariant';
 
 import { Event, synchronized } from '@dxos/async';
-import { clientServiceBundle, ClientServices, createDefaultModelFactory } from '@dxos/client-protocol';
+import { clientServiceBundle, ClientServices } from '@dxos/client-protocol';
 import { Config } from '@dxos/config';
+import { DocumentModel } from '@dxos/document-model';
 import { DataServiceImpl } from '@dxos/echo-pipeline';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
@@ -16,6 +17,7 @@ import { createWebRTCTransportFactory, NetworkManager, TransportFactory } from '
 import { trace } from '@dxos/protocols';
 import { SystemStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { Storage } from '@dxos/random-access-storage';
+import { TextModel } from '@dxos/text-model';
 
 import { DevicesServiceImpl } from '../devices';
 import { DevtoolsServiceImpl, DevtoolsHostEvents } from '../devtools';
@@ -30,6 +32,11 @@ import { SystemServiceImpl } from '../system';
 import { ServiceContext } from './service-context';
 import { ServiceRegistry } from './service-registry';
 
+// TODO(burdon): Factor out to spaces.
+export const createDefaultModelFactory = () => {
+  return new ModelFactory().registerModel(DocumentModel).registerModel(TextModel);
+};
+
 export type ClientServicesHostParams = {
   /**
    * Can be omitted if `initialize` is later called.
@@ -41,6 +48,11 @@ export type ClientServicesHostParams = {
   connectionLog?: boolean;
   storage?: Storage;
   lockKey?: string;
+  callbacks?: ClientServicesHostCallbacks;
+};
+
+export type ClientServicesHostCallbacks = {
+  onReset?: () => Promise<void>;
 };
 
 export type InitializeOptions = {
@@ -65,6 +77,7 @@ export class ClientServicesHost {
   private _signalManager?: SignalManager;
   private _networkManager?: NetworkManager;
   private _storage?: Storage;
+  private _callbacks?: ClientServicesHostCallbacks;
 
   _serviceContext!: ServiceContext;
   private _opening = false;
@@ -80,9 +93,11 @@ export class ClientServicesHost {
     storage,
     // TODO(wittjosiah): Turn this on by default.
     lockKey,
+    callbacks,
   }: ClientServicesHostParams = {}) {
     this._storage = storage;
     this._modelFactory = modelFactory;
+    this._callbacks = callbacks;
 
     if (config) {
       this.initialize({ config, transportFactory, signalManager });
@@ -150,10 +165,10 @@ export class ClientServicesHost {
    * Can only be called once.
    */
   initialize({ config, ...options }: InitializeOptions) {
-    assert(!this._open, 'service host is open');
+    invariant(!this._open, 'service host is open');
 
     if (config) {
-      assert(!this._config, 'config already set');
+      invariant(!this._config, 'config already set');
 
       this._config = config;
       if (!this._storage) {
@@ -170,7 +185,7 @@ export class ClientServicesHost {
     } = options;
     this._signalManager = signalManager;
 
-    assert(!this._networkManager, 'network manager already set');
+    invariant(!this._networkManager, 'network manager already set');
     this._networkManager = new NetworkManager({
       log: connectionLog,
       transportFactory,
@@ -187,10 +202,10 @@ export class ClientServicesHost {
     const traceId = PublicKey.random().toHex();
     log.trace('dxos.sdk.client-services-host.open', trace.begin({ id: traceId }));
 
-    assert(this._config, 'config not set');
-    assert(this._storage, 'storage not set');
-    assert(this._signalManager, 'signal manager not set');
-    assert(this._networkManager, 'network manager not set');
+    invariant(this._config, 'config not set');
+    invariant(this._storage, 'storage not set');
+    invariant(this._signalManager, 'signal manager not set');
+    invariant(this._networkManager, 'network manager not set');
 
     this._opening = true;
     log('opening...', { lockKey: this._resourceLock?.lockKey });
@@ -277,5 +292,6 @@ export class ClientServicesHost {
     await this._storage!.reset();
     log('reset');
     log.trace('dxos.sdk.client-services-host.reset', trace.end({ id: traceId }));
+    await this._callbacks?.onReset?.();
   }
 }