@dxos/client-services 0.8.4-main.b97322e → 0.8.4-main.bcb3aa67d6

package/src/packlets/spaces/data-space.ts

@@ -3,7 +3,7 @@
 //
 
 import { save } from '@automerge/automerge';
-import { type DocHandle } from '@automerge/automerge-repo';
+import { type AutomergeUrl, type DocHandle } from '@automerge/automerge-repo';
 
 import { Event, Mutex, scheduleTask, sleep, synchronized, trackLeaks } from '@dxos/async';
 import { AUTH_TIMEOUT } from '@dxos/client-protocol';
@@ -11,48 +11,49 @@ import { Context, ContextDisposedError, cancelWithContext } from '@dxos/context'
 import type { SpecificCredential } from '@dxos/credentials';
 import { timed, warnAfterTimeout } from '@dxos/debug';
 import {
-  type EchoHost,
   type DatabaseRoot,
-  createMappedFeedWriter,
+  type EchoHost,
   type MetadataStore,
   type Space,
-  FIND_PARAMS,
+  createMappedFeedWriter,
 } from '@dxos/echo-pipeline';
-import { SpaceDocVersion, type DatabaseDirectory } from '@dxos/echo-protocol';
+import { type DatabaseDirectory, SpaceDocVersion } from '@dxos/echo-protocol';
 import type { EdgeConnection, EdgeHttpClient } from '@dxos/edge-client';
 import { type FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { failedInvariant, invariant } from '@dxos/invariant';
 import { type Keyring } from '@dxos/keyring';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { CancelledError, SystemError } from '@dxos/protocols';
+import { CancelledError, type FeedProtocol, SystemError } from '@dxos/protocols';
 import {
   type CreateEpochRequest,
-  SpaceState,
   type Space as SpaceProto,
+  SpaceState,
 } from '@dxos/protocols/proto/dxos/client/services';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
 import { type FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { type SpaceCache } from '@dxos/protocols/proto/dxos/echo/metadata';
 import {
   AdmittedFeed,
-  SpaceMember,
   type Credential,
   type Epoch,
+  MembershipPolicy,
   type ProfileDocument,
+  SpaceMember,
 } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { type GossipMessage } from '@dxos/protocols/proto/dxos/mesh/teleport/gossip';
 import { type Gossip, type Presence } from '@dxos/teleport-extension-gossip';
 import { Timeframe } from '@dxos/timeframe';
 import { trace } from '@dxos/tracing';
-import { CallbackCollection, ComplexSet, type AsyncCallback } from '@dxos/util';
+import { type AsyncCallback, CallbackCollection, ComplexSet } from '@dxos/util';
+
+import { TrustedKeySetAuthVerifier } from '../identity';
 
 import { AutomergeSpaceState } from './automerge-space-state';
 import { type SigningContext } from './data-space-manager';
 import { EdgeFeedReplicator } from './edge-feed-replicator';
 import { runEpochMigration } from './epoch-migrations';
 import { NotarizationPlugin } from './notarization-plugin';
-import { TrustedKeySetAuthVerifier } from '../identity';
 
 export type DataSpaceCallbacks = {
   /**
@@ -71,7 +72,7 @@ export type DataSpaceCallbacks = {
   beforeClose?: () => Promise<void>;
 };
 
-export type DataSpaceParams = {
+export type DataSpaceProps = {
   initialState: SpaceState;
   inner: Space;
   metadataStore: MetadataStore;
@@ -83,6 +84,7 @@ export type DataSpaceParams = {
   signingContext: SigningContext;
   callbacks?: DataSpaceCallbacks;
   cache?: SpaceCache;
+  tags?: string[];
   edgeConnection?: EdgeConnection;
   edgeHttpClient?: EdgeHttpClient;
   edgeFeatures?: Runtime.Client.EdgeFeatures;
@@ -120,6 +122,9 @@ export class DataSpace {
 
   private _state = SpaceState.SPACE_CLOSED;
 
+  /** Immutable tags from space metadata, available immediately. */
+  readonly tags: string[];
+
   private _databaseRoot: DatabaseRoot | null = null;
 
   /**
@@ -135,7 +140,7 @@ export class DataSpace {
 
   public metrics: SpaceProto.Metrics = {};
 
-  constructor(params: DataSpaceParams) {
+  constructor(params: DataSpaceProps) {
     this._inner = params.inner;
     this._inner.stateUpdate.on(this._ctx, () => this.stateUpdate.emit());
 
@@ -167,6 +172,7 @@ export class DataSpace {
     });
 
     this._cache = params.cache;
+    this.tags = params.tags ?? [];
 
     if (params.edgeConnection && params.edgeFeatures?.feedReplicator) {
       this._edgeFeedReplicator = new EdgeFeedReplicator({ messenger: params.edgeConnection, spaceId: this.id });
@@ -212,6 +218,11 @@ export class DataSpace {
     return this._cache;
   }
 
+  /** Membership policy from the genesis credential, defaults to INVITE. */
+  get membershipPolicy(): MembershipPolicy {
+    return this._inner.spaceState.genesisCredential ? this._inner.spaceState.membershipPolicy : MembershipPolicy.INVITE;
+  }
+
   get automergeSpaceState() {
     return this._automergeSpaceState;
   }
@@ -229,13 +240,14 @@ export class DataSpace {
   }
 
   @synchronized
-  async open(): Promise<void> {
+  @trace.span({ showInBrowserTimeline: true })
+  async open(ctx: Context): Promise<void> {
     if (this._state === SpaceState.SPACE_CLOSED) {
-      await this._open();
+      await this._open(ctx);
     }
   }
 
-  private async _open(): Promise<void> {
+  private async _open(ctx: Context): Promise<void> {
     await this._presence.open();
     await this._gossip.open();
     await this._notarizationPlugin.open();
@@ -247,8 +259,8 @@ export class DataSpace {
       this.inner.protocol.feedAdded.append(this._onFeedAdded);
     }
 
-    await this._inner.open(new Context());
-    await this._inner.startProtocol();
+    await this._inner.open(ctx);
+    await this._inner.startProtocol(ctx);
 
     await this._edgeFeedReplicator?.open();
 
@@ -262,11 +274,12 @@ export class DataSpace {
   }
 
   @synchronized
-  async close(): Promise<void> {
-    await this._close();
+  @trace.span({ showInBrowserTimeline: true })
+  async close(ctx: Context): Promise<void> {
+    await this._close(ctx);
   }
 
-  private async _close(): Promise<void> {
+  private async _close(ctx: Context): Promise<void> {
     await this._callbacks.beforeClose?.();
 
     await this.preClose.callSerial();
@@ -284,7 +297,7 @@ export class DataSpace {
 
     await this.authVerifier.close();
 
-    await this._inner.close();
+    await this._inner.close(ctx);
     await this._inner.spaceState.removeCredentialProcessor(this._automergeSpaceState);
     await this._automergeSpaceState.close();
     await this._inner.spaceState.removeCredentialProcessor(this._notarizationPlugin);
@@ -309,7 +322,7 @@ export class DataSpace {
     scheduleTask(this._ctx, async () => {
       try {
         this.metrics.pipelineInitBegin = new Date();
-        await this.initializeDataPipeline();
+        await this.initializeDataPipeline(this._ctx);
       } catch (err) {
         if (err instanceof CancelledError || err instanceof ContextDisposedError) {
           log('data pipeline initialization cancelled', err);
@@ -328,16 +341,16 @@ export class DataSpace {
   }
 
   @trace.span({ showInBrowserTimeline: true })
-  async initializeDataPipeline(): Promise<void> {
+  async initializeDataPipeline(ctx: Context): Promise<void> {
     if (this._state !== SpaceState.SPACE_CONTROL_ONLY) {
-      throw new SystemError('Invalid operation');
+      throw new SystemError({ message: 'Invalid operation' });
     }
 
     this._state = SpaceState.SPACE_INITIALIZING;
     log('new state', { state: SpaceState[this._state] });
 
     log('initializing control pipeline');
-    await this._initializeAndReadControlPipeline();
+    await this._initializeAndReadControlPipeline(ctx);
 
     // Allow other tasks to run before loading the data pipeline.
     await sleep(1);
@@ -360,11 +373,19 @@ export class DataSpace {
     yield [this._databaseRoot.documentId, root];
 
     for (const documentUrl of this._databaseRoot.getAllLinkedDocuments()) {
-      const data = await this._echoHost.exportDoc(Context.default(), documentUrl);
+      const data = await this._echoHost.exportDoc(documentUrl);
       yield [documentUrl.replace(/^automerge:/, ''), data];
     }
   }
 
+  /**
+   * Get all feeds and their blocks for this space.
+   * Used for space archive export.
+   */
+  async getAllFeeds(): Promise<Array<{ feedId: string; feedNamespace: string; blocks: FeedProtocol.Block[] }>> {
+    return this._echoHost.getAllFeedsForSpace(this.id);
+  }
+
   private async _enterReadyState(): Promise<void> {
     await this._callbacks.beforeReady?.();
 
@@ -376,9 +397,9 @@ export class DataSpace {
   }
 
   @trace.span({ showInBrowserTimeline: true })
-  private async _initializeAndReadControlPipeline(): Promise<void> {
+  private async _initializeAndReadControlPipeline(ctx: Context): Promise<void> {
     await this._inner.controlPipeline.state.waitUntilReachedTargetTimeframe({
-      ctx: this._ctx,
+      ctx,
       timeout: 10_000,
       breakOnStall: false,
     });
@@ -450,6 +471,9 @@ export class DataSpace {
 
         log('credentials notarized');
       } catch (err) {
+        if (err instanceof ContextDisposedError) {
+          return;
+        }
         log.error('error notarizing credentials for feed admission', err);
         throw err;
       }
@@ -470,7 +494,9 @@ export class DataSpace {
         await warnAfterTimeout(5_000, 'Automerge root doc load timeout (DataSpace)', async () => {
           handle = await cancelWithContext(
             this._ctx,
-            this._echoHost.automergeRepo.find<DatabaseDirectory>(rootUrl as any, FIND_PARAMS),
+            this._echoHost.loadDoc<DatabaseDirectory>(this._ctx, rootUrl as AutomergeUrl, {
+              fetchFromNetwork: true,
+            }),
           );
           await cancelWithContext(this._ctx, handle.whenReady());
         });
@@ -491,7 +517,7 @@ export class DataSpace {
 
         // TODO(dmaretskyi): Close roots.
         // TODO(dmaretskyi): How do we handle changing to the next EPOCH?
-        const root = await this._echoHost.openSpaceRoot(this.id, handle.url);
+        const root = await this._echoHost.openSpaceRoot(this._ctx, this.id, handle.url);
 
         // NOTE: Make sure this assignment happens synchronously together with the state change.
         this._databaseRoot = root;
@@ -568,25 +594,24 @@ export class DataSpace {
   }
 
   @synchronized
-  async activate(): Promise<void> {
+  async activate(ctx: Context): Promise<void> {
     if (![SpaceState.SPACE_CLOSED, SpaceState.SPACE_INACTIVE].includes(this._state)) {
       return;
     }
 
     await this._metadataStore.setSpaceState(this.key, SpaceState.SPACE_ACTIVE);
-    await this._open();
+    await this._open(ctx);
     this.initializeDataPipelineAsync();
   }
 
   @synchronized
-  async deactivate(): Promise<void> {
+  async deactivate(ctx: Context): Promise<void> {
     if (this._state === SpaceState.SPACE_INACTIVE) {
       return;
     }
-    // Unregister from data service.
     await this._metadataStore.setSpaceState(this.key, SpaceState.SPACE_INACTIVE);
     if (this._state !== SpaceState.SPACE_CLOSED) {
-      await this._close();
+      await this._close(ctx);
     }
     this._state = SpaceState.SPACE_INACTIVE;
     log('new state', { state: SpaceState[this._state] });

package/src/packlets/spaces/edge-feed-replicator.test.ts

@@ -6,10 +6,10 @@ import { decode as decodeCbor, encode as encodeCbor } from 'cbor-x';
 import { getPort } from 'get-port-please';
 import { describe, expect, onTestFinished, test, vi } from 'vitest';
 
-import { sleep, Trigger } from '@dxos/async';
+import { Trigger, sleep } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { valueEncoding } from '@dxos/echo-pipeline';
-import { createEphemeralEdgeIdentity, EdgeClient, EdgeIdentityChangedError } from '@dxos/edge-client';
+import { EdgeClient, EdgeIdentityChangedError, createEphemeralEdgeIdentity } from '@dxos/edge-client';
 import { createTestEdgeWsServer } from '@dxos/edge-client/testing';
 import { FeedFactory, FeedStore, type FeedWrapper } from '@dxos/feed-store';
 import { Keyring } from '@dxos/keyring';
@@ -45,7 +45,7 @@ describe('EdgeFeedReplicator', () => {
     const { endpoint, admitConnection, messageSink } = await createEdge();
     const { messenger } = await createClient(endpoint);
     admitConnection.wake();
-    await expect.poll(() => messenger.status).toBe(EdgeStatus.CONNECTED);
+    await expect.poll(() => messenger.status.state).toBe(EdgeStatus.ConnectionState.CONNECTED);
 
     await attachReplicator(messenger);
     await expect.poll(() => messageSink.length).toEqual(1);
@@ -107,7 +107,7 @@ describe('EdgeFeedReplicator', () => {
     const { feed } = await attachReplicator(messenger);
     await appendMessage(feed);
 
-    sendSpy.mockImplementationOnce(async (request: any) => {
+    sendSpy.mockImplementationOnce(async (_ctx: any, request: any) => {
       sendResponseMessage(request, encodeCbor({ type: 'metadata', feedKey: feed.key.toHex(), length: 0 }));
       return Promise.resolve();
     });

package/src/packlets/spaces/edge-feed-replicator.ts

@@ -15,14 +15,14 @@ import { log, logInfo } from '@dxos/log';
 import { EdgeService } from '@dxos/protocols';
 import { buf } from '@dxos/protocols/buf';
 import {
-  MessageSchema as RouterMessageSchema,
   type Message as RouterMessage,
+  MessageSchema as RouterMessageSchema,
 } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 import type { FeedBlock, ProtocolMessage } from '@dxos/protocols/feed-replication';
 import { EdgeStatus } from '@dxos/protocols/proto/dxos/client/services';
 import { ComplexMap, arrayToBuffer, bufferToArray, defaultMap, rangeFromTo } from '@dxos/util';
 
-export type EdgeFeedReplicatorParams = {
+export type EdgeFeedReplicatorProps = {
   messenger: EdgeConnection;
   spaceId: SpaceId;
 };
@@ -47,7 +47,7 @@ export class EdgeFeedReplicator extends Resource {
    */
   private _pushMutex = new ComplexMap<PublicKey, Mutex>(PublicKey.hash);
 
-  constructor({ messenger, spaceId }: EdgeFeedReplicatorParams) {
+  constructor({ messenger, spaceId }: EdgeFeedReplicatorProps) {
     super();
     this._messenger = messenger;
     this._spaceId = spaceId;
@@ -87,7 +87,7 @@ export class EdgeFeedReplicator extends Resource {
 
   private async _handleReconnect(): Promise<void> {
     await this._resetConnection();
-    if (this._messenger.status === EdgeStatus.CONNECTED) {
+    if (this._messenger.status.state === EdgeStatus.ConnectionState.CONNECTED) {
       this._startReplication();
     }
   }
@@ -132,7 +132,7 @@ export class EdgeFeedReplicator extends Resource {
 
   private async _replicateFeed(ctx: Context, feed: FeedWrapper<any>): Promise<void> {
     log('replicateFeed', { key: feed.key });
-    await this._sendMessage({
+    await this._sendMessage(ctx, {
       type: 'get-metadata',
       feedKey: feed.key.toHex(),
     });
@@ -142,7 +142,7 @@ export class EdgeFeedReplicator extends Resource {
     });
   }
 
-  private async _sendMessage(message: ProtocolMessage): Promise<void> {
+  private async _sendMessage(ctx: Context, message: ProtocolMessage): Promise<void> {
     if (!this._connectionCtx) {
       log('message dropped because connection was disposed');
       return;
@@ -160,6 +160,7 @@ export class EdgeFeedReplicator extends Resource {
 
     log('send', { type: message.type });
     await this._messenger.send(
+      ctx,
       buf.create(RouterMessageSchema, {
         source: {
           identityKey: this._messenger.identityKey,
@@ -194,7 +195,7 @@ export class EdgeFeedReplicator extends Resource {
           if (message.length > feed.length) {
             log('requesting missing blocks', logMeta);
 
-            await this._sendMessage({
+            await this._sendMessage(this._connectionCtx!, {
               type: 'request',
               feedKey: feedKey.toHex(),
               range: { from: feed.length, to: message.length },
@@ -202,7 +203,7 @@ export class EdgeFeedReplicator extends Resource {
           } else if (message.length < feed.length) {
             log('pushing blocks to remote', logMeta);
 
-            await this._pushBlocks(feed, message.length, feed.length);
+            await this._pushBlocks(this._connectionCtx!, feed, message.length, feed.length);
           }
 
           break;
@@ -229,7 +230,7 @@ export class EdgeFeedReplicator extends Resource {
     });
   }
 
-  private async _pushBlocks(feed: FeedWrapper<any>, from: number, to: number): Promise<void> {
+  private async _pushBlocks(ctx: Context, feed: FeedWrapper<any>, from: number, to: number): Promise<void> {
     log('pushing blocks', { feed: feed.key.toHex(), from, to });
 
     const blocks: FeedBlock[] = await Promise.all(
@@ -247,7 +248,7 @@ export class EdgeFeedReplicator extends Resource {
       }),
     );
 
-    await this._sendMessage({
+    await this._sendMessage(ctx, {
       type: 'data',
       feedKey: feed.key.toHex(),
       blocks,
@@ -283,7 +284,7 @@ export class EdgeFeedReplicator extends Resource {
 
     const remoteLength = this._remoteLength.get(feed.key)!;
     if (remoteLength < feed.length) {
-      await this._pushBlocks(feed, remoteLength, feed.length);
+      await this._pushBlocks(this._connectionCtx!, feed, remoteLength, feed.length);
     }
   }
 

package/src/packlets/spaces/epoch-migrations.ts

@@ -36,8 +36,8 @@ const LOAD_DOC_TIMEOUT = 10_000;
 export const runEpochMigration = async (ctx: Context, context: MigrationContext): Promise<MigrationResult> => {
   switch (context.migration) {
     case CreateEpochRequest.Migration.INIT_AUTOMERGE: {
-      const document = context.echoHost.createDoc();
-      await context.echoHost.flush();
+      const document = await context.echoHost.createDoc();
+      await context.echoHost.flush(ctx);
       return { newRoot: document.url };
     }
     case CreateEpochRequest.Migration.PRUNE_AUTOMERGE_ROOT_HISTORY: {
@@ -48,8 +48,8 @@ export const runEpochMigration = async (ctx: Context, context: MigrationContext)
         timeout: LOAD_DOC_TIMEOUT,
       });
 
-      const newRoot = context.echoHost.createDoc(rootHandle.doc());
-      await context.echoHost.flush();
+      const newRoot = await context.echoHost.createDoc(rootHandle.doc());
+      await context.echoHost.flush(ctx);
       return { newRoot: newRoot.url };
     }
     case CreateEpochRequest.Migration.FRAGMENT_AUTOMERGE_ROOT: {
@@ -63,7 +63,7 @@ export const runEpochMigration = async (ctx: Context, context: MigrationContext)
       invariant(context.newAutomergeRoot);
 
       // Defensive programming - it should be the responsibility of the caller to flush the new root.
-      await context.echoHost.flush();
+      await context.echoHost.flush(ctx);
       return {
         newRoot: context.newAutomergeRoot,
       };

package/src/packlets/spaces/genesis.ts

@@ -6,7 +6,7 @@ import { createCredential } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import { type Space } from '@dxos/echo-pipeline';
 import { type Keyring } from '@dxos/keyring';
-import { AdmittedFeed, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
+import { AdmittedFeed, MembershipPolicy, SpaceMember } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { Timeframe } from '@dxos/timeframe';
 
 import { type SigningContext } from './data-space-manager';
@@ -16,6 +16,8 @@ export const spaceGenesis = async (
   signingContext: SigningContext,
   space: Space,
   automergeRoot?: string,
+  tags?: string[],
+  membershipPolicy?: MembershipPolicy,
 ) => {
   // TODO(dmaretskyi): Find a way to reconcile with credential generator.
   const credentials = [
@@ -26,6 +28,8 @@ export const spaceGenesis = async (
       assertion: {
         '@type': 'dxos.halo.credentials.SpaceGenesis',
         spaceKey: space.key,
+        tags: tags ?? [],
+        membershipPolicy: membershipPolicy ?? MembershipPolicy.INVITE,
       },
     }),
 
@@ -39,6 +43,7 @@ export const spaceGenesis = async (
         role: SpaceMember.Role.OWNER,
         profile: signingContext.getProfile(),
         genesisFeedKey: space.controlFeedKey ?? failUndefined(),
+        tags: tags ?? [],
       },
     }),
 

package/src/packlets/spaces/notarization-plugin.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { onTestFinished, describe, expect, test } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Context } from '@dxos/context';
 import { CredentialGenerator } from '@dxos/credentials';
@@ -13,7 +13,7 @@ import { log } from '@dxos/log';
 import { AdmittedFeed, type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import { TestBuilder, type TestConnection, TestPeer } from '@dxos/teleport/testing';
 
-import { NotarizationPlugin, type NotarizationPluginParams } from './notarization-plugin';
+import { NotarizationPlugin, type NotarizationPluginProps } from './notarization-plugin';
 
 class TestAgent extends TestPeer {
   private readonly _ctx = new Context();
@@ -21,7 +21,7 @@ class TestAgent extends TestPeer {
   feed = new MockFeedWriter<Credential>();
   notarizationPlugin: NotarizationPlugin;
 
-  constructor(params: NotarizationPluginParams) {
+  constructor(params: NotarizationPluginProps) {
     super();
     this.notarizationPlugin = new NotarizationPlugin(params);
     this.feed.written.on(this._ctx, async ([credential]) => {

package/src/packlets/spaces/notarization-plugin.ts

@@ -2,15 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import { DeferredTask, Event, scheduleTask, sleep, TimeoutError, Trigger, scheduleMicroTask } from '@dxos/async';
-import { type Context, rejectOnDispose, Resource } from '@dxos/context';
+import { DeferredTask, Event, TimeoutError, Trigger, scheduleMicroTask, scheduleTask, sleep } from '@dxos/async';
+import { type Context, Resource, rejectOnDispose } from '@dxos/context';
 import { type CredentialProcessor, verifyCredential } from '@dxos/credentials';
 import { type EdgeHttpClient } from '@dxos/edge-client';
 import { type FeedWriter } from '@dxos/feed-store';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { type SpaceId } from '@dxos/keys';
-import { logInfo, log } from '@dxos/log';
+import { log, logInfo } from '@dxos/log';
 import { EdgeCallFailedError } from '@dxos/protocols';
 import { schema } from '@dxos/protocols/proto';
 import { type Runtime } from '@dxos/protocols/proto/dxos/config';
@@ -33,14 +33,14 @@ const WRITER_NOT_SET_ERROR_CODE = 'WRITER_NOT_SET';
 
 const credentialCodec = schema.getCodecForType('dxos.halo.credentials.Credential');
 
-export type NotarizationPluginParams = {
+export type NotarizationPluginProps = {
   spaceId: SpaceId;
   edgeClient?: EdgeHttpClient;
   edgeFeatures?: Runtime.Client.EdgeFeatures;
   activeEdgePollingInterval?: number;
 };
 
-export type NotarizeParams = {
+export type NotarizeProps = {
   /**
    * For cancellation.
    */
@@ -97,7 +97,7 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
 
   private readonly _edgeClient: EdgeHttpClient | undefined;
 
-  constructor(params: NotarizationPluginParams) {
+  constructor(params: NotarizationPluginProps) {
     super();
     this._spaceId = params.spaceId;
     this._activeEdgePollingInterval = params.activeEdgePollingInterval ?? DEFAULT_ACTIVE_EDGE_POLLING_INTERVAL;
@@ -149,7 +149,7 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
     retryTimeout = DEFAULT_RETRY_TIMEOUT,
     successDelay = DEFAULT_SUCCESS_DELAY,
     edgeRetryJitter,
-  }: NotarizeParams): Promise<void> {
+  }: NotarizeProps): Promise<void> {
     log('notarize', { credentials });
     invariant(
       credentials.every((credential) => credential.id),
@@ -246,6 +246,7 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
     scheduleTask(ctx, async () => {
       try {
         await client.notarizeCredentials(
+          ctx,
           this._spaceId,
           { credentials: encodedCredentials },
           { retry: { count: MAX_EDGE_RETRIES, timeout: timeouts.retryTimeout, jitter: timeouts.jitter } },
@@ -302,7 +303,7 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
   private _notarizePendingEdgeCredentials(client: EdgeHttpClient, writer: FeedWriter<Credential>): void {
     scheduleMicroTask(this._ctx, async () => {
       try {
-        const response = await client.getCredentialsForNotarization(this._spaceId, {
+        const response = await client.getCredentialsForNotarization(this._ctx, this._spaceId, {
           retry: { count: MAX_EDGE_RETRIES },
         });
 
@@ -392,21 +393,21 @@ export class NotarizationPlugin extends Resource implements CredentialProcessor
 }
 
 const handleEdgeError = (error: any) => {
-  if (!(error instanceof EdgeCallFailedError) || error.errorData) {
+  if (!(error instanceof EdgeCallFailedError) || error.data) {
     log.catch(error);
   } else {
-    log.info('Edge notarization failure', { reason: error.reason });
+    log.info('Edge notarization failure', { message: error.message });
   }
 };
 
-export type NotarizationTeleportExtensionParams = {
+export type NotarizationTeleportExtensionProps = {
   onOpen: () => Promise<void>;
   onClose: () => Promise<void>;
   onNotarize: (request: NotarizeRequest) => Promise<void>;
 };
 
 export class NotarizationTeleportExtension extends RpcExtension<Services, Services> {
-  constructor(private readonly _params: NotarizationTeleportExtensionParams) {
+  constructor(private readonly _params: NotarizationTeleportExtensionProps) {
     super({
       requested: {
         NotarizationService: schema.getService('dxos.mesh.teleport.notarization.NotarizationService'),

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

@@ -2,17 +2,19 @@
 // Copyright 2023 DXOS.org
 //
 
-import { afterEach, onTestFinished, beforeEach, describe, expect, test } from 'vitest';
+import { afterEach, beforeEach, describe, expect, onTestFinished, test } from 'vitest';
 
 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 { SpacesServiceImpl } from './spaces-service';
 import { type ServiceContext } from '../services';
 import { createServiceContext } from '../testing';
 
+import { SpacesServiceImpl } from './spaces-service';
+
 describe('SpacesService', () => {
   let serviceContext: ServiceContext;
   let spacesService: SpacesService;
@@ -32,12 +34,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);
     });
@@ -59,9 +63,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();
@@ -87,7 +91,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;