@dxos/client 2.33.9-dev.bba8fc00 → 2.33.9-dev.ceab0857

package/src/packlets/proto/index.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * as proto from './gen';
+export { schema } from './gen';
+export * from './gen/dxos/client';
+export * from './gen/dxos/config';
+export * from './gen/dxos/credentials';
+export * from './gen/dxos/echo/feed';
+export * from './gen/dxos/echo/invitation';
+export * from './gen/dxos/echo/service';
+export * from './gen/dxos/echo/snapshot';
+export * from './gen/dxos/echo/timeframe';
+export * from './gen/dxos/devtools';
+export * from './gen/dxos/halo/keys';
+export * from './gen/dxos/rpc';

package/src/{api/client.ts → packlets/proxy/client-proxy.ts}

@@ -1,5 +1,5 @@
 //
-// Copyright 2020 DXOS.org
+// Copyright 2022 DXOS.org
 //
 
 import debug from 'debug';
@@ -12,16 +12,19 @@ import { OpenProgress } from '@dxos/echo-db';
 import { ModelConstructor } from '@dxos/model-factory';
 import { RpcPort } from '@dxos/rpc';
 
-import { createDevtoolsRpcServer } from '../devtools';
-import { Runtime } from '../proto/gen/dxos/config';
-import { ClientServiceProvider, ClientServices, ClientServiceHost, ClientServiceProxy, HaloSigner } from '../services';
-import { createWindowMessagePort, isNode } from '../util';
-import { DXOS_VERSION } from '../version';
-import { InvalidConfigurationError, RemoteServiceConnectionTimeout } from './errors';
-import { Echo, EchoProxy, Halo, HaloProxy } from './proxies';
+import { InvalidConfigurationError, ClientServiceProvider, ClientServices, Echo, Halo, HaloSigner } from '../api';
+import { Runtime } from '../proto';
+import { createDevtoolsRpcServer } from './devtools';
+import { EchoProxy } from './echo-proxy';
+import { HaloProxy } from './halo-proxy';
+import { ClientServiceProxy } from './service-proxy';
+import { createSingletonPort } from './singleton-port';
+import { DXOS_VERSION } from './version';
 
-const log = debug('dxos:client');
+const log = debug('dxos:client-proxy');
 
+// TODO(wittjosiah): Should be kube.local or equivalent.
+const DEFAULT_SINGLETON_HOST = 'http://localhost:8080';
 const EXPECTED_CONFIG_VERSION = 1;
 
 export const defaultConfig: ConfigObject = { version: 1 };
@@ -31,7 +34,7 @@ export const defaultTestingConfig: ConfigObject = {
   runtime: {
     services: {
       signal: {
-        server: 'ws://localhost:4000'
+        server: 'ws://localhost:4000/.well-known/dx/signal'
       }
     }
   }
@@ -41,7 +44,12 @@ export interface ClientOptions {
   /**
    * Only used when remote=true.
    */
-  rpcPort?: RpcPort;
+  rpcPort?: RpcPort
+
+  /**
+   *
+   */
+  serviceProvider?: ClientServiceProvider
 
   /**
    *
@@ -54,10 +62,6 @@ export interface ClientOptions {
   timeout?: number
 }
 
-/**
- * The main DXOS client API.
- * An entrypoint to ECHO, HALO, MESH, and DXNS.
- */
 export class Client {
   public readonly version = DXOS_VERSION;
 
@@ -98,14 +102,14 @@ export class Client {
   }
 
   toString () {
-    return `Client(${JSON.stringify(this.info())})`;
+    return `Client(${JSON.stringify(this.info)})`;
   }
 
-  info () {
+  get info () {
     return {
       initialized: this.initialized,
-      echo: this.echo.info(),
-      halo: this.halo.info()
+      echo: this.echo.info,
+      halo: this.halo.info
     };
   }
 
@@ -139,13 +143,6 @@ export class Client {
 
   // TODO(burdon): Expose mesh for messaging?
 
-  /**
-   * Returns true if client is connected to a remote services protvider.
-   */
-  get isRemote (): boolean {
-    return this._serviceProvider instanceof ClientServiceProxy;
-  }
-
   /**
    * Client services that can be proxied.
    */
@@ -170,62 +167,29 @@ export class Client {
       throw new TimeoutError(`Initialize timed out after ${t}s.`);
     }, t * 1000);
 
-    if (this._mode === Runtime.Client.Mode.REMOTE) {
-      await this.initializeRemote(onProgressCallback);
-    } else if (this._mode === Runtime.Client.Mode.LOCAL) {
-      await this.initializeLocal(onProgressCallback);
+    if (this._options.serviceProvider) {
+      this._serviceProvider = this._options.serviceProvider;
     } else {
-      await this.initializeAuto(onProgressCallback);
-    }
-
-    if (typeof window !== 'undefined') {
-      await createDevtoolsRpcServer(this, this._serviceProvider);
+      const singletonSource = this._config.get('runtime.client.singletonSource') ?? DEFAULT_SINGLETON_HOST;
+      this._serviceProvider = new ClientServiceProxy(
+        this._options.rpcPort ?? await createSingletonPort(singletonSource),
+        this._options.timeout
+      );
     }
 
     this._halo = new HaloProxy(this._serviceProvider);
     this._echo = new EchoProxy(this._serviceProvider, this._halo);
 
+    await this._serviceProvider.open(onProgressCallback);
     await this._halo._open();
     await this._echo._open();
 
-    this._initialized = true; // TODO(burdon): Initialized === halo.initialized?
-    clearInterval(timeout);
-  }
-
-  private async initializeRemote (onProgressCallback: Parameters<this['initialize']>[0]) {
-    if (!this._options.rpcPort && isNode()) {
-      throw new Error('RPC port is required to run client in remote mode on Node environment.');
+    if (typeof window !== 'undefined') {
+      await createDevtoolsRpcServer(this, this._serviceProvider);
     }
 
-    log('Creating client proxy.');
-    this._serviceProvider = new ClientServiceProxy(
-      this._options.rpcPort ?? createWindowMessagePort(),
-      this._options.timeout
-    );
-    await this._serviceProvider.open(onProgressCallback);
-  }
-
-  private async initializeLocal (onProgressCallback: Parameters<this['initialize']>[0]) {
-    log('Creating client host.');
-    this._serviceProvider = new ClientServiceHost(this._config, this._options);
-    await this._serviceProvider.open(onProgressCallback);
-  }
-
-  private async initializeAuto (onProgressCallback: Parameters<this['initialize']>[0]) {
-    if (!this._options.rpcPort && isNode()) {
-      await this.initializeLocal(onProgressCallback);
-    } else {
-      try {
-        await this.initializeRemote(onProgressCallback);
-      } catch (error) {
-        if (error instanceof RemoteServiceConnectionTimeout) {
-          log('Failed to connect to remote services. Starting local services.');
-          await this.initializeLocal(onProgressCallback);
-        } else {
-          throw error;
-        }
-      }
-    }
+    this._initialized = true; // TODO(burdon): Initialized === halo.initialized?
+    clearInterval(timeout);
   }
 
   /**

package/src/{devtools/devtools-rpc-server.ts → packlets/proxy/devtools.ts}

@@ -6,13 +6,20 @@ import debug from 'debug';
 
 import { createBundledRpcServer, RpcPeer, RpcPort } from '@dxos/rpc';
 
-import { Client } from '../api';
-import { clientServiceBundle, ClientServiceProvider } from '../services';
-import { DevtoolsHook } from './devtools-context';
+import { clientServiceBundle, ClientServiceProvider } from '../api';
+import { Client } from './client-proxy';
 
 const log = debug('dxos:client:devtools');
 const error = log.extend('error');
 
+/**
+ * A hook bound to window.__DXOS__.
+ */
+export interface DevtoolsHook {
+  client: Client
+  openClientRpcServer: () => Promise<boolean>
+}
+
 const port: RpcPort = {
   send: async message => window.postMessage({
     data: Array.from(message),

package/src/{api/proxies → packlets/proxy}/echo-proxy.ts

@@ -13,33 +13,11 @@ import { ObjectModel } from '@dxos/object-model';
 import { PublicKey } from '@dxos/protocols';
 import { ComplexMap, SubscriptionGroup } from '@dxos/util';
 
-import { ClientServiceHost, ClientServiceProvider } from '../../services';
-import { Invitation, InvitationProxy } from '../invitations';
+import { ClientServiceProvider, Echo, Party, PartyInvitation } from '../api';
 import { HaloProxy } from './halo-proxy';
-import { Party, PartyProxy } from './party-proxy';
-
-export class PartyInvitation extends Invitation<Party> {
-  /**
-   * Wait for the invitation flow to complete and return the target party.
-   */
-  getParty (): Promise<Party> {
-    return this.wait();
-  }
-}
-
-/**
- * ECHO API.
- */
-// TODO(burdon): Separate public API form implementation (move comments here).
-export interface Echo {
-  info (): { parties: number }
-  registerModel (constructor: ModelConstructor<any>): void
-  createParty (): Promise<Party>
-  cloneParty (snapshot: PartySnapshot): Promise<Party>
-  getParty (partyKey: PartyKey): Party | undefined
-  queryParties (): ResultSet<Party>
-  acceptInvitation (invitationDescriptor: InvitationDescriptor): PartyInvitation
-}
+import { InvitationProxy } from './invitation-proxy';
+import { PartyProxy } from './party-proxy';
+import { ClientServiceProxy } from './service-proxy';
 
 /**
  * Client proxy to local/remote ECHO service.
@@ -54,14 +32,15 @@ export class EchoProxy implements Echo {
     private readonly _serviceProvider: ClientServiceProvider,
     private readonly _haloProxy: HaloProxy
   ) {
-    this._modelFactory = _serviceProvider instanceof ClientServiceHost
-      ? _serviceProvider.echo.modelFactory : new ModelFactory();
+    // TODO(wittjosiah): Reconcile service provider host with interface.
+    this._modelFactory = _serviceProvider instanceof ClientServiceProxy
+      ? new ModelFactory() : (_serviceProvider as any).echo.modelFactory;
 
     this._modelFactory.registerModel(ObjectModel); // Register object-model by default.
   }
 
   toString () {
-    return `EchoProxy(${JSON.stringify(this.info())})`;
+    return `EchoProxy(${JSON.stringify(this.info)})`;
   }
 
   get modelFactory (): ModelFactory {
@@ -69,15 +48,16 @@ export class EchoProxy implements Echo {
   }
 
   get networkManager () {
-    if (this._serviceProvider instanceof ClientServiceHost) {
-      return this._serviceProvider.echo.networkManager;
+    if (this._serviceProvider instanceof ClientServiceProxy) {
+      throw new Error('Network Manager not available in service proxy.');
     }
 
-    throw new Error('Network Manager not available in service proxy.');
+    // TODO(wittjosiah): Reconcile service provider host with interface.
+    return (this._serviceProvider as any).echo.networkManager;
   }
 
   // TODO(burdon): Client ID?
-  info () {
+  get info () {
     return {
       parties: this._parties.size
     };

package/src/{api/proxies → packlets/proxy}/halo-proxy.ts

@@ -5,43 +5,11 @@
 import { Event } from '@dxos/async';
 import { DeviceInfo, keyPairFromSeedPhrase, KeyRecord } from '@dxos/credentials';
 import { Contact, CreateProfileOptions, InvitationDescriptor, PartyMember, ResultSet } from '@dxos/echo-db';
-import { PublicKey } from '@dxos/protocols';
 import { SubscriptionGroup } from '@dxos/util';
 
-import { Profile, SignRequest, SignResponse } from '../../proto/gen/dxos/client';
-import { ClientServiceProvider } from '../../services';
-import { Invitation, InvitationProxy, InvitationRequest } from '../invitations';
-
-/**
- * HALO API.
- */
-// TODO(burdon): Separate public API form implementation (move comments here).
-export interface Halo {
-  info (): { key?: PublicKey }
-
-  get profile (): Profile | undefined
-  createProfile (options?: CreateProfileOptions): Promise<Profile>
-  recoverProfile (seedPhrase: string): Promise<Profile>
-
-  sign (request: SignRequest): Promise<SignResponse>
-  addKeyRecord (keyRecord: KeyRecord): Promise<void>
-
-  /**
-   * @deprecated
-   */
-  subscribeToProfile (callback: (profile: Profile) => void): void
-
-  queryContacts (): ResultSet<Contact>
-  createInvitation (): Promise<InvitationRequest>
-  acceptInvitation (invitationDescriptor: InvitationDescriptor): Invitation
-
-  queryDevices (): Promise<DeviceInfo[]>
-  setDevicePreference (key: string, value: string): Promise<void>
-  getDevicePreference (key: string): Promise<string | undefined>
-
-  setGlobalPreference (key: string, value: string): Promise<void>
-  getGlobalPreference (key: string): Promise<string | undefined>
-}
+import { ClientServiceProvider, Halo, Invitation, InvitationRequest } from '../api';
+import { Profile, SignRequest } from '../proto';
+import { InvitationProxy } from './invitation-proxy';
 
 /**
  * Client proxy to local/remote HALO service.
@@ -61,10 +29,10 @@ export class HaloProxy implements Halo {
   ) {}
 
   toString () {
-    return `HaloProxy(${JSON.stringify(this.info())})`;
+    return `HaloProxy(${JSON.stringify(this.info)})`;
   }
 
-  info () {
+  get info () {
     return {
       key: this._profile?.publicKey
     };

package/src/packlets/proxy/index.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+export * from './client-proxy';
+export * from './devtools';
+export * from './echo-proxy';
+export * from './halo-proxy';
+export * from './invitation-proxy';
+export * from './party-proxy';
+export * from './serializer';
+export * from './service-proxy';
+export * from './singleton-port';
+export * from './version';

package/src/{api/invitations → packlets/proxy}/invitation-proxy.ts

@@ -10,8 +10,8 @@ import { throwUnhandledRejection } from '@dxos/debug';
 import { InvitationDescriptor, InvitationDescriptorType } from '@dxos/echo-db';
 import { RpcClosedError } from '@dxos/rpc';
 
-import { AuthenticateInvitationRequest, InvitationRequest as InvitationRequestProto, InvitationState, RedeemedInvitation as RedeemedInvitationProto } from '../../proto/gen/dxos/client';
-import { InvitationRequest } from './invitation-request';
+import { InvitationRequest } from '../api';
+import { AuthenticateInvitationRequest, InvitationRequest as InvitationRequestProto, InvitationState, RedeemedInvitation as RedeemedInvitationProto } from '../proto';
 
 export interface CreateInvitationRequestOpts {
   stream: Stream<InvitationRequestProto>

package/src/{api/proxies → packlets/proxy}/party-proxy.ts

@@ -10,65 +10,17 @@ import {
   Database,
   Item,
   RemoteDatabaseBackend,
-  ResultSet,
-  PartyMember
+  streamToResultSet
 } from '@dxos/echo-db';
-import { PartyKey, PartySnapshot } from '@dxos/echo-protocol';
+import { PartyKey } from '@dxos/echo-protocol';
 import { ModelFactory } from '@dxos/model-factory';
 import { ObjectModel, ObjectProperties } from '@dxos/object-model';
 import { PublicKey } from '@dxos/protocols';
 
-import { Party as PartyProto, PartyDetails } from '../../proto/gen/dxos/client';
-import { ClientServiceHost, ClientServiceProvider, ClientServiceProxy } from '../../services';
-import { streamToResultSet } from '../../util';
-import { InvitationRequest, InvitationProxy } from '../invitations';
-
-export interface CreationInvitationOptions {
-  inviteeKey?: PublicKey
-}
-
-/**
- * Party API.
- */
-// TODO(burdon): Separate public API form implementation (move comments here).
-export interface Party {
-  get key (): PublicKey
-  get isOpen (): boolean
-  get isActive (): boolean
-
-  // TODO(burdon): Verbs should be on same interface.
-  get database (): Database
-  get select (): Database['select']
-  get reduce (): Database['reduce']
-
-  initialize (): Promise<void>
-  destroy (): Promise<void>
-
-  open (): Promise<void>
-  close (): Promise<void>
-  setActive (active: boolean, options: ActivationOptions): Promise<void>
-
-  setTitle (title: string): Promise<void>
-  getTitle (): string
-
-  // TODO(burdon): Rename (info?)
-  getDetails(): Promise<PartyDetails>
-
-  get properties (): ObjectProperties
-  /**
-   * @deprecated
-   */
-  setProperty (key: string, value?: any): Promise<void>
-  /**
-   * @deprecated
-   */
-  getProperty (key: string, defaultValue?: any): any
-
-  queryMembers (): ResultSet<PartyMember>
-  createInvitation (options?: CreationInvitationOptions): Promise<InvitationRequest>
-
-  createSnapshot (): Promise<PartySnapshot>
-}
+import { ClientServiceProvider, CreationInvitationOptions, InvitationRequest, Party } from '../api';
+import { Party as PartyProto, PartyDetails } from '../proto';
+import { InvitationProxy } from './invitation-proxy';
+import { ClientServiceProxy } from './service-proxy';
 
 /**
  * Main public Party API.
@@ -105,8 +57,9 @@ export class PartyProxy implements Party {
         new RemoteDatabaseBackend(this._serviceProvider.services.DataService, this._key),
         memberKey
       );
-    } else if (this._serviceProvider instanceof ClientServiceHost) {
-      const party = this._serviceProvider.echo.getParty(this._key) ?? failUndefined();
+    } else if ((this._serviceProvider as any).echo) {
+      // TODO(wittjosiah): Reconcile service provider host with interface.
+      const party = (this._serviceProvider as any).echo.getParty(this._key) ?? failUndefined();
       this._database = party.database;
     } else {
       throw new Error('Unrecognized service provider.');

package/src/{api → packlets/proxy}/serializer.ts

@@ -2,8 +2,9 @@
 // Copyright 2022 DXOS.org
 //
 
-import { Client, Party } from '../api';
-import { schema } from '../proto/gen';
+import { Party } from '../api';
+import { schema } from '../proto';
+import { Client } from './client-proxy';
 
 const partyCodec = schema.getCodecForType('dxos.echo.snapshot.PartySnapshot');
 

package/src/{services → packlets/proxy}/service-proxy.ts

@@ -6,8 +6,7 @@ import { promiseTimeout } from '@dxos/async';
 import { OpenProgress } from '@dxos/echo-db';
 import { createBundledRpcClient, ProtoRpcClient, RpcPort } from '@dxos/rpc';
 
-import { RemoteServiceConnectionTimeout } from '../api';
-import { clientServiceBundle, ClientServiceProvider, ClientServices } from './client-service';
+import { clientServiceBundle, ClientServiceProvider, ClientServices, RemoteServiceConnectionTimeout } from '../api';
 
 /**
  * Implements services that are not local to the app.

package/src/packlets/proxy/singleton-port.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2021 DXOS.org
+//
+
+import debug from 'debug';
+
+import { RpcPort } from '@dxos/rpc';
+import { isNode } from '@dxos/util';
+
+import { SingletonMessage } from '../proto';
+
+const log = debug('dxos:client:singleton-port');
+
+const waitForClient = () => {
+  return new Promise<void>(resolve => {
+    const messageHandler = (event: MessageEvent<SingletonMessage>) => {
+      if (event.data?.type === SingletonMessage.Type.CLIENT_READY) {
+        window.removeEventListener('message', messageHandler);
+        resolve();
+      }
+    };
+
+    window.addEventListener('message', messageHandler);
+  });
+};
+
+export const createSingletonPort = async (singletonSource: string): Promise<RpcPort> => {
+  if (isNode()) {
+    throw new Error('Connecting to singleton client is not available in Node environment.');
+  }
+
+  const singleton = document.createElement('iframe') as HTMLIFrameElement;
+  singleton.id = 'dxos-client-singleton';
+  singleton.src = singletonSource;
+  singleton.setAttribute('style', 'display: none;');
+  document.body.appendChild(singleton);
+
+  await waitForClient();
+
+  return {
+    send: async message => singleton.contentWindow?.postMessage({
+      type: SingletonMessage.Type.WINDOW_MESSAGE,
+      data: Array.from(message)
+    }, '*'),
+    subscribe: callback => {
+      const handler = (event: MessageEvent<SingletonMessage>) => {
+        const message = event.data;
+        if (message?.type !== SingletonMessage.Type.WINDOW_MESSAGE) {
+          return;
+        }
+
+        log('Received message from singleton client:', message);
+        callback(new Uint8Array(message.data!));
+      };
+
+      window.addEventListener('message', handler);
+      return () => window.removeEventListener('message', handler);
+    }
+  };
+};

package/src/{services → packlets/services}/impl/halo.ts

@@ -5,10 +5,11 @@
 import assert from 'node:assert';
 
 import { Stream } from '@dxos/codec-protobuf';
-import { ECHO } from '@dxos/echo-db';
+import { ECHO, resultSetToStream } from '@dxos/echo-db';
 import { ObjectModel } from '@dxos/object-model';
 import { SubscriptionGroup } from '@dxos/util';
 
+import { HaloSigner } from '../../api';
 import {
   AddKeyRecordRequest,
   Contacts,
@@ -18,9 +19,8 @@ import {
   SetPreferenceRequest,
   GetPreferenceRequest,
   GetPreferenceResponse
-} from '../../proto/gen/dxos/client';
-import { resultSetToStream } from '../../util';
-import { CreateServicesOpts, HaloSigner } from './types';
+} from '../../proto';
+import { CreateServicesOpts } from './types';
 
 /**
  * HALO service implementation.

package/src/{services → packlets/services}/impl/index.ts

@@ -2,5 +2,4 @@
 // Copyright 2020 DXOS.org
 //
 
-export { HaloSigner } from './types';
 export * from './services';

package/src/{services → packlets/services}/impl/party.ts

@@ -9,29 +9,28 @@ import { latch } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf';
 import { defaultSecretValidator, generatePasscode, SecretProvider } from '@dxos/credentials';
 import { InvalidStateError, raise } from '@dxos/debug';
-import { ECHO, InvitationDescriptor, InvitationDescriptorType, PartyNotFoundError } from '@dxos/echo-db';
+import { ECHO, InvitationDescriptor, InvitationDescriptorType, PartyNotFoundError, resultSetToStream } from '@dxos/echo-db';
 
 import {
+  AuthenticateInvitationRequest,
+  CreateInvitationRequest,
+  CreateSnaspotRequest,
+  GetPartyDetailsRequest,
+  InvitationDescriptor as InvitationDescriptorProto,
+  InvitationRequest,
   InvitationState,
+  Party,
+  PartyDetails,
   PartyService as IPartyService,
+  PartySnapshot,
+  RedeemedInvitation,
+  SetPartyStateRequest,
+  SubscribeMembersRequest,
   SubscribeMembersResponse,
   SubscribePartiesResponse,
-  SubscribePartyResponse,
   SubscribePartyRequest,
-  SetPartyStateRequest,
-  CreateInvitationRequest,
-  AuthenticateInvitationRequest,
-  InvitationRequest,
-  RedeemedInvitation,
-  SubscribeMembersRequest,
-  Party,
-  CreateSnaspotRequest,
-  GetPartyDetailsRequest,
-  PartyDetails
-} from '../../proto/gen/dxos/client';
-import { InvitationDescriptor as InvitationDescriptorProto } from '../../proto/gen/dxos/echo/invitation';
-import { PartySnapshot } from '../../proto/gen/dxos/echo/snapshot';
-import { resultSetToStream } from '../../util';
+  SubscribePartyResponse
+} from '../../proto';
 import { CreateServicesOpts, InviteeInvitation, InviteeInvitations } from './types';
 
 /**

package/src/{services → packlets/services}/impl/profile.ts

@@ -13,6 +13,7 @@ import { ECHO, InvitationDescriptor } from '@dxos/echo-db';
 import {
   AuthenticateInvitationRequest,
   CreateProfileRequest,
+  InvitationDescriptor as InvitationDescriptorProto,
   InvitationRequest,
   InvitationState,
   Profile,
@@ -20,8 +21,7 @@ import {
   RecoverProfileRequest,
   RedeemedInvitation,
   SubscribeProfileResponse
-} from '../../proto/gen/dxos/client';
-import { InvitationDescriptor as InvitationDescriptorProto } from '../../proto/gen/dxos/echo/invitation';
+} from '../../proto';
 import { CreateServicesOpts, InviteeInvitation, InviteeInvitations } from './types';
 
 /**

package/src/{services → packlets/services}/impl/services.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { ClientServices } from '../../services';
+import { ClientServices } from '../../api';
 import { createHaloService } from './halo';
 import { createPartyService } from './party';
 import { createProfileService } from './profile';