@dxos/client-services 0.8.4-main.fffef41 → 0.9.0

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

@@ -8,10 +8,10 @@ import { Trigger } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { PublicKey } from '@dxos/keys';
 import { type Space, type SpacesService } from '@dxos/protocols/proto/dxos/client/services';
+import { MembershipPolicy } from '@dxos/protocols/proto/dxos/halo/credentials';
 
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
-
 import { SpacesServiceImpl } from './spaces-service';
 
 describe('SpacesService', () => {
@@ -21,10 +21,15 @@ describe('SpacesService', () => {
   beforeEach(async () => {
     serviceContext = await createServiceContext();
     await serviceContext.open(new Context());
-    spacesService = new SpacesServiceImpl(serviceContext.identityManager, serviceContext.spaceManager, async () => {
-      await serviceContext.initialized.wait();
-      return serviceContext.dataSpaceManager!;
-    });
+    spacesService = new SpacesServiceImpl(
+      serviceContext.identityManager,
+      serviceContext.spaceManager,
+      serviceContext.echoHost,
+      async () => {
+        await serviceContext.initialized.wait();
+        return serviceContext.dataSpaceManager!;
+      },
+    );
   });
 
   afterEach(async () => {
@@ -33,12 +38,14 @@ describe('SpacesService', () => {
 
   describe('createSpace', () => {
     test('fails if no identity is available', async () => {
-      await expect(spacesService.createSpace()).rejects.toBeInstanceOf(Error);
+      await expect(spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE })).rejects.toBeInstanceOf(
+        Error,
+      );
     });
 
     test('creates a new space', async () => {
       await serviceContext.createIdentity();
-      const space = await spacesService.createSpace();
+      const space = await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE });
       expect(space).to.exist;
       expect(space.spaceKey).to.be.instanceof(PublicKey);
     });
@@ -60,9 +67,9 @@ describe('SpacesService', () => {
     test('returns list of existing spaces', async () => {
       await serviceContext.createIdentity();
       const existingSpaces = [
-        await spacesService.createSpace(),
-        await spacesService.createSpace(),
-        await spacesService.createSpace(),
+        await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE }),
+        await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE }),
+        await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE }),
       ];
 
       const query = spacesService.querySpaces();
@@ -88,7 +95,7 @@ describe('SpacesService', () => {
       expect(await result.wait()).to.be.length(0);
 
       result.reset();
-      const space = await spacesService.createSpace();
+      const space = await spacesService.createSpace({ membershipPolicy: MembershipPolicy.INVITE });
       const spaces = await result.wait();
       expect(spaces).to.be.length(1);
       expect(spaces?.[0].spaceKey.equals(space.spaceKey)).to.be.true;

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

@@ -5,7 +5,9 @@
 import type { AutomergeUrl } from '@automerge/automerge-repo';
 
 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,
   createAdmissionCredentials,
@@ -13,7 +15,8 @@ import {
   getCredentialAssertion,
 } from '@dxos/credentials';
 import { raise } from '@dxos/debug';
-import { type SpaceManager } from '@dxos/echo-pipeline';
+import { type EchoHost, type SpaceManager } from '@dxos/echo-host';
+import { type DatabaseDirectory } from '@dxos/echo-protocol';
 import { writeMessages } from '@dxos/feed-store';
 import { assertArgument, assertState, invariant } from '@dxos/invariant';
 import { SpaceId } from '@dxos/keys';
@@ -21,6 +24,7 @@ import { log } from '@dxos/log';
 import {
   ApiError,
   AuthorizationError,
+  FeedProtocol,
   IdentityNotInitializedError,
   SpaceNotFoundError,
   encodeError,
@@ -40,11 +44,13 @@ import {
   type QueryCredentialsRequest,
   type QuerySpacesResponse,
   type Space,
+  SpaceArchive,
   SpaceMember,
   SpaceState,
   type SpacesService,
   type SubscribeMessagesRequest,
   type UpdateMemberRoleRequest,
+  type CreateSpaceRequest,
   type UpdateSpaceRequest,
   type WriteCredentialsRequest,
 } from '@dxos/protocols/proto/dxos/client/services';
@@ -54,8 +60,14 @@ import { trace } from '@dxos/tracing';
 import { type Provider } from '@dxos/util';
 
 import { type IdentityManager } from '../identity';
-import { SpaceArchiveWriter, extractSpaceArchive } from '../space-export';
-
+import {
+  SpaceArchiveWriter,
+  detectSpaceArchiveFormat,
+  extractSpaceArchive,
+  readSerializedSpaceArchive,
+  writeSerializedSpaceArchive,
+  objJsonToObjectStructure,
+} from '../space-export';
 import { type DataSpace } from './data-space';
 import { type DataSpaceManager } from './data-space-manager';
 
@@ -63,37 +75,48 @@ export class SpacesServiceImpl implements SpacesService {
   constructor(
     private readonly _identityManager: IdentityManager,
     private readonly _spaceManager: SpaceManager,
+    private readonly _echoHost: EchoHost,
     private readonly _getDataSpaceManager: Provider<Promise<DataSpaceManager>>,
   ) {}
 
-  async createSpace(): Promise<Space> {
+  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();
+    const space = await dataSpaceManager.createSpace(ctx, {
+      tags: request?.tags,
+      membershipPolicy: request?.membershipPolicy,
+    });
     await this._updateMetrics();
     return this._serializeSpace(space);
   }
 
-  async updateSpace({ spaceKey, state, edgeReplication }: UpdateSpaceRequest): Promise<void> {
+  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();
+          await space.activate(ctx);
           break;
 
         case SpaceState.SPACE_INACTIVE:
-          await space.deactivate();
+          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('Invalid space state');
+          throw new ApiError({ message: 'Invalid space state' });
       }
     }
 
     if (edgeReplication !== undefined) {
-      await dataSpaceManager.setSpaceEdgeReplicationSetting(spaceKey, edgeReplication);
+      await dataSpaceManager.setSpaceEdgeReplicationSetting(ctx, spaceKey, edgeReplication);
     }
   }
 
@@ -104,9 +127,12 @@ export class SpacesServiceImpl implements SpacesService {
       throw new SpaceNotFoundError(request.spaceKey);
     }
     if (!space.spaceState.hasMembershipManagementPermission(identity.identityKey)) {
-      throw new AuthorizationError('No member management permission.', {
-        spaceKey: space.key,
-        role: space.spaceState.getMemberRole(identity.identityKey),
+      throw new AuthorizationError({
+        message: 'No member management permission.',
+        context: {
+          spaceKey: space.key,
+          role: space.spaceState.getMemberRole(identity.identityKey),
+        },
       });
     }
     const credentials = await createAdmissionCredentials(
@@ -259,18 +285,26 @@ export class SpacesServiceImpl implements SpacesService {
     });
   }
 
-  async joinBySpaceKey({ spaceKey }: JoinBySpaceKeyRequest): Promise<JoinSpaceResponse> {
+  async joinBySpaceKey({ spaceKey }: JoinBySpaceKeyRequest, options?: RequestOptions): Promise<JoinSpaceResponse> {
+    const ctx = options?.ctx ?? Context.default();
     const dataSpaceManager = await this._getDataSpaceManager();
-    const credential = await dataSpaceManager.requestSpaceAdmissionCredential(spaceKey);
-    return this._joinByAdmission({ credential });
+    const credential = await dataSpaceManager.requestSpaceAdmissionCredential(ctx, spaceKey);
+    return this._joinByAdmission(ctx, { credential });
   }
 
   async exportSpace(request: ExportSpaceRequest): Promise<ExportSpaceResponse> {
-    await using writer = await new SpaceArchiveWriter().open();
     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 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');
@@ -280,23 +314,92 @@ export class SpacesServiceImpl implements SpacesService {
       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 archive = await writer.finish();
     return { archive };
   }
 
-  async importSpace(request: ImportSpaceRequest): Promise<ImportSpaceResponse> {
+  async importSpace(request: ImportSpaceRequest, options?: RequestOptions): Promise<ImportSpaceResponse> {
+    const ctx = options?.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 extracted = await extractSpaceArchive(request.archive);
     invariant(extracted.metadata.echo?.currentRootUrl, 'Space archive does not contain a root URL');
-    const space = await dataSpaceManager.createSpace({
+    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 };
   }
 
-  private async _joinByAdmission({ credential }: ContactAdmission): Promise<JoinSpaceResponse> {
+  /**
+   * 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}.
+   */
+  private async _hydrateSpaceFromSerialized(
+    space: DataSpace,
+    serialized: ReturnType<typeof readSerializedSpaceArchive>,
+  ): Promise<void> {
+    const databaseRoot = space.databaseRoot;
+    assertState(databaseRoot, 'Space database root is not ready');
+
+    databaseRoot.handle.change((doc: DatabaseDirectory) => {
+      if (!doc.objects) {
+        doc.objects = {};
+      }
+      for (const obj of serialized.objects) {
+        doc.objects[obj.id] = objJsonToObjectStructure(obj);
+      }
+    });
+
+    for (const feed of serialized.feeds ?? []) {
+      if (feed.messages.length === 0) {
+        continue;
+      }
+
+      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)),
+        });
+      } catch (err) {
+        log.warn('failed to import feed data', { feedObjectId: feed.feedObjectId, error: err });
+      }
+    }
+  }
+
+  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;
@@ -305,9 +408,10 @@ export class SpacesServiceImpl implements SpacesService {
     const dataSpaceManager = await this._getDataSpaceManager();
     let dataSpace = dataSpaceManager.spaces.get(assertion.spaceKey);
     if (!dataSpace) {
-      dataSpace = await dataSpaceManager.acceptSpace({
+      dataSpace = await dataSpaceManager.acceptSpace(ctx, {
         spaceKey: assertion.spaceKey,
         genesisFeedKey: assertion.genesisFeedKey,
+        tags: assertion.tags,
       });
       await myIdentity.controlPipeline.writer.write({ credential: { credential } });
     }
@@ -360,6 +464,8 @@ export class SpacesServiceImpl implements SpacesService {
         }),
       ),
       creator: space.inner.spaceState.creator?.key,
+      tags: space.tags,
+      membershipPolicy: space.membershipPolicy,
       cache: space.cache,
       metrics: space.metrics,
       edgeReplication: space.getEdgeReplicationSetting(),
@@ -368,9 +474,9 @@ export class SpacesServiceImpl implements SpacesService {
 
   private _requireIdentity() {
     if (!this._identityManager.identity) {
-      throw new IdentityNotInitializedError(
-        'This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo',
-      );
+      throw new IdentityNotInitializedError({
+        message: 'This device has no HALO identity available. See https://docs.dxos.org/guide/platform/halo',
+      });
     }
     return this._identityManager.identity;
   }

package/src/packlets/storage/index.ts

@@ -5,3 +5,4 @@
 export * from './storage';
 export * from './level';
 export * from './profile-archive';
+export * from './profile-archive-sqlite';

package/src/packlets/storage/profile-archive-sqlite.test.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { cbor } from '@automerge/automerge-repo';
+import { describe, test } from 'vitest';
+
+import { ProfileArchiveEntryType } from '@dxos/protocols';
+
+import { decodeProfileArchive, encodeProfileArchive } from './profile-archive';
+import {
+  createSqliteProfileArchive,
+  getSqliteProfileEntries,
+  isValidSqliteDatabase,
+  OPFS_SQLITE_DB_FILENAME,
+} from './profile-archive-sqlite';
+
+const sqliteHeader = (): Uint8Array => {
+  const bytes = new Uint8Array(16);
+  bytes.set(new TextEncoder().encode('SQLite format 3\u0000'));
+  return bytes;
+};
+
+describe('profile-archive-sqlite', () => {
+  test('isValidSqliteDatabase accepts SQLite header', ({ expect }) => {
+    expect(isValidSqliteDatabase(sqliteHeader())).toBe(true);
+    expect(isValidSqliteDatabase(new Uint8Array([1, 2, 3]))).toBe(false);
+  });
+
+  test('createSqliteProfileArchive includes optional origin in meta', ({ expect }) => {
+    const archive = createSqliteProfileArchive(OPFS_SQLITE_DB_FILENAME, sqliteHeader(), {
+      origin: 'main.composer.space',
+    });
+
+    expect(archive.meta.origin).toBe('main.composer.space');
+    expect(archive.meta.timestamp).toBeTruthy();
+  });
+
+  test('createSqliteProfileArchive round-trips through CBOR', ({ expect }) => {
+    const database = sqliteHeader();
+    const archive = createSqliteProfileArchive(OPFS_SQLITE_DB_FILENAME, database);
+    const decoded = decodeProfileArchive(encodeProfileArchive(archive));
+
+    expect(decoded.storage).toHaveLength(1);
+    expect(decoded.storage[0]?.type).toBe(ProfileArchiveEntryType.SQLITE_DATABASE);
+    expect(getSqliteProfileEntries(decoded)).toEqual([
+      { opfsFilename: OPFS_SQLITE_DB_FILENAME, database: expect.any(Uint8Array) },
+    ]);
+  });
+
+  test('getSqliteProfileEntries skips invalid sqlite payloads', ({ expect }) => {
+    const archive = {
+      meta: { timestamp: '2026-01-01T00:00:00.000Z' },
+      storage: [
+        {
+          type: ProfileArchiveEntryType.SQLITE_DATABASE,
+          key: OPFS_SQLITE_DB_FILENAME,
+          value: new Uint8Array([0, 1, 2]),
+        },
+      ],
+    };
+
+    expect(getSqliteProfileEntries(archive)).toEqual([]);
+  });
+
+  test('createSqliteProfileArchive rejects invalid sqlite bytes', ({ expect }) => {
+    expect(() => createSqliteProfileArchive(OPFS_SQLITE_DB_FILENAME, new Uint8Array([0]))).toThrow(
+      /Invalid SQLite database/,
+    );
+  });
+
+  test('CBOR decode preserves sqlite entry shape', ({ expect }) => {
+    const archive = createSqliteProfileArchive(OPFS_SQLITE_DB_FILENAME, sqliteHeader());
+    const encoded = cbor.encode(archive);
+    const decoded = cbor.decode(encoded) as ReturnType<typeof decodeProfileArchive>;
+
+    expect(getSqliteProfileEntries(decoded)).toHaveLength(1);
+  });
+});

package/src/packlets/storage/profile-archive-sqlite.ts

@@ -0,0 +1,100 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type ProfileArchive, ProfileArchiveEntryType } from '@dxos/protocols';
+
+/** Default OPFS SQLite database name used by Composer recovery and the OPFS worker. */
+export const OPFS_SQLITE_DB_FILENAME = 'DXOS' as const;
+
+const SQLITE_MAGIC = new TextEncoder().encode('SQLite format 3\u0000');
+
+/**
+ * Returns true when `bytes` begins with the SQLite 3 file header.
+ */
+export const isValidSqliteDatabase = (bytes: Uint8Array): boolean => {
+  if (bytes.byteLength < SQLITE_MAGIC.byteLength) {
+    return false;
+  }
+  for (let index = 0; index < SQLITE_MAGIC.byteLength; index++) {
+    if (bytes[index] !== SQLITE_MAGIC[index]) {
+      return false;
+    }
+  }
+  return true;
+};
+
+const coerceToUint8Array = (value: unknown): Uint8Array | undefined => {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (Array.isArray(value)) {
+    return new Uint8Array(value);
+  }
+  return undefined;
+};
+
+export type SqliteProfileEntry = {
+  opfsFilename: string;
+  database: Uint8Array;
+};
+
+export type CreateSqliteProfileArchiveOptions = {
+  /** Host where the export was created (stored in archive meta). */
+  origin?: string;
+};
+
+/**
+ * Build a profile archive containing a single validated SQLITE_DATABASE entry.
+ */
+export const createSqliteProfileArchive = (
+  opfsFilename: string,
+  database: Uint8Array,
+  options?: CreateSqliteProfileArchiveOptions,
+): ProfileArchive => {
+  if (!isValidSqliteDatabase(database)) {
+    throw new Error('Invalid SQLite database (missing SQLite format 3 header)');
+  }
+
+  return {
+    meta: {
+      timestamp: new Date().toISOString(),
+      ...(options?.origin ? { origin: options.origin } : {}),
+    },
+    storage: [
+      {
+        type: ProfileArchiveEntryType.SQLITE_DATABASE,
+        key: opfsFilename,
+        value: database,
+      },
+    ],
+  };
+};
+
+/**
+ * Extract validated SQLITE_DATABASE entries from a profile archive.
+ */
+export const getSqliteProfileEntries = (archive: ProfileArchive): SqliteProfileEntry[] => {
+  const entries: SqliteProfileEntry[] = [];
+
+  for (const entry of archive.storage) {
+    if (entry.type !== ProfileArchiveEntryType.SQLITE_DATABASE) {
+      continue;
+    }
+    if (typeof entry.key !== 'string') {
+      continue;
+    }
+
+    const database = coerceToUint8Array(entry.value);
+    if (!database || !isValidSqliteDatabase(database)) {
+      continue;
+    }
+
+    entries.push({ opfsFilename: entry.key, database });
+  }
+
+  return entries;
+};

package/src/packlets/storage/profile-archive.ts

@@ -90,6 +90,9 @@ export const importProfileData = async (
         batch.put(entry.key, entry.value, { keyEncoding: 'binary', valueEncoding: 'binary' });
         break;
       }
+      case ProfileArchiveEntryType.SQLITE_DATABASE:
+        log.warn('Skipping SQLITE_DATABASE entry (import via OPFS recovery API)', { key: entry.key });
+        break;
       default:
         throw new Error(`Invalid entry type: ${entry.type}`);
     }

package/src/packlets/storage/storage.ts

@@ -14,16 +14,16 @@ import StorageDriver = Runtime.Client.Storage.StorageDriver;
 export const createStorageObjects = (config: Runtime.Client.Storage) => {
   const { persistent = false, keyStore, dataStore } = config ?? {};
   if (persistent && dataStore === StorageDriver.RAM) {
-    throw new InvalidConfigError('RAM storage cannot be used in persistent mode.');
+    throw new InvalidConfigError({ message: 'RAM storage cannot be used in persistent mode.' });
   }
   if (!persistent && dataStore !== undefined && dataStore !== StorageDriver.RAM) {
-    throw new InvalidConfigError('Cannot use a persistent storage in not persistent mode.');
+    throw new InvalidConfigError({ message: 'Cannot use a persistent storage in not persistent mode.' });
   }
   if (persistent && keyStore === StorageDriver.RAM) {
-    throw new InvalidConfigError('RAM key storage cannot be used in persistent mode.');
+    throw new InvalidConfigError({ message: 'RAM key storage cannot be used in persistent mode.' });
   }
   if (!persistent && keyStore !== StorageDriver.RAM && keyStore !== undefined) {
-    throw new InvalidConfigError('Cannot use a persistent key storage in not persistent mode.');
+    throw new InvalidConfigError({ message: 'Cannot use a persistent key storage in not persistent mode.' });
   }
 
   return {

package/src/packlets/testing/invitation-utils.ts

@@ -4,6 +4,7 @@
 
 import { Trigger } from '@dxos/async';
 import { type AuthenticatingInvitation, type CancellableInvitation, InvitationEncoder } from '@dxos/client-protocol';
+import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { type DeviceProfileDocument } from '@dxos/protocols/proto/dxos/halo/credentials';
@@ -36,15 +37,15 @@ export type PerformInvitationCallbacks<T> = {
   onError?: (value: T) => boolean | void;
 };
 
-export type PerformInvitationParams = {
+export type PerformInvitationProps = {
   host: ServiceContext | InvitationHost;
   guest: ServiceContext | InvitationGuest;
+  guestDeviceProfile?: DeviceProfileDocument;
   options?: Partial<Invitation>;
   hooks?: {
     host?: PerformInvitationCallbacks<CancellableInvitation>;
     guest?: PerformInvitationCallbacks<AuthenticatingInvitation>;
   };
-  guestDeviceProfile?: DeviceProfileDocument;
   codeInputDelay?: number;
 };
 
@@ -52,14 +53,17 @@ export type Result = { invitation?: Invitation; error?: Error };
 
 // TODO(burdon): Make async.
 // TODO(burdon): Rename startInvitation.
+/**
+ *
+ */
 export const performInvitation = ({
   host,
   guest,
+  guestDeviceProfile,
   options,
   hooks,
-  guestDeviceProfile,
   codeInputDelay,
-}: PerformInvitationParams): [Promise<Result>, Promise<Result>] => {
+}: PerformInvitationProps): [Promise<Result>, Promise<Result>] => {
   let guestError = false;
   let guestConnected = false;
   let wereConnected = false;
@@ -226,7 +230,7 @@ export const createInvitation = async (
   };
 
   if (host instanceof ServiceContext) {
-    return host.invitationsManager.createInvitation({
+    return host.invitationsManager.createInvitation(new Context(), {
       kind: Invitation.Kind.SPACE,
       ...options,
     });
@@ -243,7 +247,7 @@ export const acceptInvitation = (
   invitation = sanitizeInvitation(invitation);
 
   if (guest instanceof ServiceContext) {
-    return guest.invitationsManager.acceptInvitation({
+    return guest.invitationsManager.acceptInvitation(new Context(), {
       invitation,
       deviceProfile: guestDeviceProfile,
     });