@dxos/echo-pipeline 0.8.3 → 0.8.4-main.1068cf700f

package/src/query/query-planner.ts

@@ -2,6 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Order } from '@dxos/echo';
 import { type QueryAST } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
 import type { DXN, SpaceId } from '@dxos/keys';
@@ -35,6 +36,8 @@ export class QueryPlanner {
     let plan = this._generate(query, { ...DEFAULT_CONTEXT, originalQuery: query });
     plan = this._optimizeEmptyFilters(plan);
     plan = this._optimizeSoloUnions(plan);
+    plan = this._ensureOrderStep(plan);
+    plan = this._optimizeLimits(plan);
     return plan;
   }
 
@@ -54,12 +57,19 @@ export class QueryPlanner {
         return this._generateRelationTraversalClause(query, context);
       case 'reference-traversal':
         return this._generateReferenceTraversalClause(query, context);
+      case 'hierarchy-traversal':
+        return this._generateHierarchyTraversalClause(query, context);
       case 'union':
         return this._generateUnionClause(query, context);
       case 'set-difference':
         return this._generateSetDifferenceClause(query, context);
+      case 'order':
+        return this._generateOrderClause(query, context);
+      case 'limit':
+        return this._generateLimitClause(query, context);
       default:
-        throw new QueryError(`Unsupported query type: ${(query as any).type}`, {
+        throw new QueryError({
+          message: `Unsupported query type: ${(query as any).type}`,
           context: { query: context.originalQuery },
         });
     }
@@ -72,6 +82,12 @@ export class QueryPlanner {
     if (query.options.spaceIds) {
       newContext.selectionSpaces = query.options.spaceIds as readonly SpaceId[];
     }
+    if (query.options.allQueuesFromSpaces !== undefined) {
+      newContext.selectionAllQueuesFromSpaces = query.options.allQueuesFromSpaces;
+    }
+    if (query.options.queues) {
+      newContext.selectionQueues = query.options.queues as readonly DXN.String[];
+    }
     if (query.options.deleted) {
       newContext.deletedHandling = query.options.deleted;
     }
@@ -86,6 +102,7 @@ export class QueryPlanner {
   // TODO(dmaretskyi): If the tip of the query ast is a [select, ...filter] shape we can reorder the filters so the query is most efficient.
   private _generateSelectionFromFilter(filter: QueryAST.Filter, context: GenerationContext): QueryPlan.Plan {
     switch (filter.type) {
+      // Props
       case 'object': {
         if (
           context.selectionInverted &&
@@ -102,7 +119,10 @@ export class QueryPlanner {
           ]);
         }
         if (context.selectionInverted) {
-          throw new QueryError('Query too complex', { context: { query: context.originalQuery } });
+          throw new QueryError({
+            message: 'Query too complex',
+            context: { query: context.originalQuery },
+          });
         }
 
         // Try to utilize indexes during selection, prioritizing selecting by id, then by typename.
@@ -112,6 +132,8 @@ export class QueryPlanner {
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'IdSelector',
                 objectIds: filter.id,
@@ -128,6 +150,8 @@ export class QueryPlanner {
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'TypeSelector',
                 typename: [filter.typename as DXN.String],
@@ -135,9 +159,10 @@ export class QueryPlanner {
               },
             },
             ...this._generateDeletedHandlingSteps(context),
+            // TODO(dmaretskyi): Normally we could skip filtering by typename here, but since the index does not separate schema versions, we need to do additional filter to only select the correct version.
             {
               _tag: 'FilterStep',
-              filter: { ...filter, typename: null },
+              filter: { ...filter },
             },
           ]);
         } else {
@@ -145,6 +170,8 @@ export class QueryPlanner {
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'WildcardSelector',
               },
@@ -157,44 +184,76 @@ export class QueryPlanner {
           ]);
         }
       }
+
+      // Tag
+      case 'tag': {
+        return QueryPlan.Plan.make([
+          {
+            _tag: 'SelectStep',
+            spaces: context.selectionSpaces,
+            allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+            queues: context.selectionQueues,
+            selector: {
+              _tag: 'WildcardSelector',
+            },
+          },
+          ...this._generateDeletedHandlingSteps(context),
+          {
+            _tag: 'FilterStep',
+            filter: { ...filter },
+          },
+        ]);
+      }
+
+      // Text
       case 'text-search': {
         return QueryPlan.Plan.make([
           {
             _tag: 'SelectStep',
             spaces: context.selectionSpaces,
+            allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+            queues: context.selectionQueues,
             selector: {
               _tag: 'TextSelector',
               text: filter.text,
               searchKind: filter.searchKind ?? this._options.defaultTextSearchKind,
+              typename: null,
             },
           },
           ...this._generateDeletedHandlingSteps(context),
         ]);
       }
+
+      // Compare
       case 'compare':
-        throw new QueryError('Query too complex', { context: { query: context.originalQuery } });
+        throw new QueryError({ message: 'Query too complex', context: { query: context.originalQuery } });
       case 'in':
-        throw new QueryError('Query too complex', { context: { query: context.originalQuery } });
+        throw new QueryError({ message: 'Query too complex', context: { query: context.originalQuery } });
       case 'range':
-        throw new QueryError('Query too complex', { context: { query: context.originalQuery } });
+        throw new QueryError({ message: 'Query too complex', context: { query: context.originalQuery } });
+
+      // Boolean
       case 'not':
         return this._generateSelectionFromFilter(filter.filter, {
           ...context,
           selectionInverted: !context.selectionInverted,
         });
       case 'and':
-        throw new QueryError('Query too complex', { context: { query: context.originalQuery } });
+        throw new QueryError({ message: 'Query too complex', context: { query: context.originalQuery } });
       case 'or':
         // Optimized case
         if (filter.filters.every(isTrivialTypenameFilter)) {
-          const typenames = filter.filters.map((f) => {
-            invariant(f.type === 'object' && f.typename !== null);
-            return f.typename;
+          const typenames = filter.filters.map((filter) => {
+            invariant(filter.type === 'object' && filter.typename !== null);
+            return filter.typename;
           });
+
           return QueryPlan.Plan.make([
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'TypeSelector',
                 typename: typenames as DXN.String[],
@@ -202,13 +261,18 @@ export class QueryPlanner {
               },
             },
             ...this._generateDeletedHandlingSteps(context),
+            {
+              _tag: 'FilterStep',
+              filter: { ...filter },
+            },
           ]);
         } else {
-          throw new QueryError('Query too complex', { context: { query: context.originalQuery } });
+          throw new QueryError({ message: 'Query too complex', context: { query: context.originalQuery } });
         }
 
       default:
-        throw new QueryError(`Unsupported filter type: ${(filter as any).type}`, {
+        throw new QueryError({
+          message: `Unsupported filter type: ${(filter as any).type}`,
           context: { query: context.originalQuery },
         });
     }
@@ -286,7 +350,7 @@ export class QueryPlanner {
         traversal: {
           _tag: 'ReferenceTraversal',
           direction: 'incoming',
-          property: query.property,
+          property: query.property ?? null,
         },
       },
       ...this._generateDeletedHandlingSteps(context),
@@ -392,6 +456,23 @@ export class QueryPlanner {
     ]);
   }
 
+  private _generateHierarchyTraversalClause(
+    query: QueryAST.QueryHierarchyTraversalClause,
+    context: GenerationContext,
+  ): QueryPlan.Plan {
+    return QueryPlan.Plan.make([
+      ...this._generate(query.anchor, context).steps,
+      {
+        _tag: 'TraverseStep',
+        traversal: {
+          _tag: 'HierarchyTraversal',
+          direction: query.direction,
+        },
+      },
+      ...this._generateDeletedHandlingSteps(context),
+    ]);
+  }
+
   /**
    * Removes filter steps that have no predicates.
    */
@@ -425,6 +506,176 @@ export class QueryPlanner {
     // TODO(dmaretskyi): Implement this.
     return plan;
   }
+
+  private _generateOrderClause(query: QueryAST.QueryOrderClause, context: GenerationContext): QueryPlan.Plan {
+    return QueryPlan.Plan.make([
+      ...this._generate(query.query, context).steps,
+      {
+        _tag: 'OrderStep',
+        order: query.order,
+      },
+    ]);
+  }
+
+  private _generateLimitClause(query: QueryAST.QueryLimitClause, context: GenerationContext): QueryPlan.Plan {
+    return QueryPlan.Plan.make([
+      ...this._generate(query.query, context).steps,
+      {
+        _tag: 'LimitStep',
+        limit: query.limit,
+      },
+    ]);
+  }
+
+  // After complete plan is built, inspect it from the end:
+  //   - Walk backwards until hitting an object set changer.
+  //   - If an order step is found, skip.
+  //   - Otherwise insert natural order before any limit steps (since limit should be applied after ordering).
+  // This method is recursive and also processes sub-plans in unions and set differences.
+  private _ensureOrderStep(plan: QueryPlan.Plan): QueryPlan.Plan {
+    // First, recursively process any sub-plans.
+    const processedSteps = plan.steps.map((step): QueryPlan.Step => {
+      if (step._tag === 'UnionStep') {
+        return {
+          _tag: 'UnionStep',
+          plans: step.plans.map((subPlan) => this._ensureOrderStep(subPlan)),
+        };
+      } else if (step._tag === 'SetDifferenceStep') {
+        return {
+          _tag: 'SetDifferenceStep',
+          source: this._ensureOrderStep(step.source),
+          exclude: this._ensureOrderStep(step.exclude),
+        };
+      }
+      return step;
+    });
+
+    const processedPlan = QueryPlan.Plan.make(processedSteps);
+
+    const OBJECT_SET_CHANGERS = new Set(['SelectStep', 'TraverseStep', 'UnionStep', 'SetDifferenceStep']);
+    for (let i = processedPlan.steps.length - 1; i >= 0; i--) {
+      const step = processedPlan.steps[i];
+      if (step._tag === 'OrderStep') {
+        return processedPlan;
+      }
+      if (OBJECT_SET_CHANGERS.has(step._tag)) {
+        break;
+      }
+    }
+
+    // Find the position to insert the order step (before any limit steps).
+    let insertIndex = processedPlan.steps.length;
+    for (let i = processedPlan.steps.length - 1; i >= 0; i--) {
+      if (processedPlan.steps[i]._tag === 'LimitStep') {
+        insertIndex = i;
+      } else {
+        break;
+      }
+    }
+
+    const newSteps = [...processedPlan.steps];
+    newSteps.splice(insertIndex, 0, {
+      _tag: 'OrderStep',
+      order: [Order.natural.ast],
+    });
+
+    return QueryPlan.Plan.make(newSteps);
+  }
+
+  /**
+   * Propagates limits from LimitStep to SelectStep and OrderStep when possible.
+   * Limits can only be propagated if there are no unions or traversals between the LimitStep and SelectStep/OrderStep.
+   */
+  private _optimizeLimits(plan: QueryPlan.Plan): QueryPlan.Plan {
+    // First, recursively process any sub-plans.
+    const processedSteps = plan.steps.map((step): QueryPlan.Step => {
+      if (step._tag === 'UnionStep') {
+        return {
+          _tag: 'UnionStep',
+          plans: step.plans.map((subPlan) => this._optimizeLimits(subPlan)),
+        };
+      } else if (step._tag === 'SetDifferenceStep') {
+        return {
+          _tag: 'SetDifferenceStep',
+          source: this._optimizeLimits(step.source),
+          exclude: this._optimizeLimits(step.exclude),
+        };
+      }
+      return step;
+    });
+
+    // Find if there's a LimitStep at the end (possibly after OrderStep).
+    let limitStepIndex = -1;
+    let limitValue: number | undefined;
+
+    for (let i = processedSteps.length - 1; i >= 0; i--) {
+      const step = processedSteps[i];
+      if (step._tag === 'LimitStep') {
+        limitStepIndex = i;
+        limitValue = step.limit;
+        break;
+      }
+      // Only allow OrderStep after LimitStep when looking backwards.
+      if (step._tag !== 'OrderStep') {
+        break;
+      }
+    }
+
+    if (limitStepIndex === -1 || limitValue === undefined) {
+      return QueryPlan.Plan.make(processedSteps);
+    }
+
+    // Check if we can propagate the limit to a SelectStep and/or OrderStep.
+    // We can only do this if there are no unions, traversals, or set differences between them.
+    const BLOCKERS = new Set(['UnionStep', 'TraverseStep', 'SetDifferenceStep']);
+
+    let selectStepIndex = -1;
+    let orderStepIndex = -1;
+    for (let i = 0; i < limitStepIndex; i++) {
+      const step = processedSteps[i];
+      if (step._tag === 'SelectStep') {
+        selectStepIndex = i;
+      }
+      if (step._tag === 'OrderStep') {
+        orderStepIndex = i;
+      }
+      if (BLOCKERS.has(step._tag)) {
+        // Found a blocker after the select/order step - can't propagate.
+        selectStepIndex = -1;
+        orderStepIndex = -1;
+      }
+    }
+
+    if (selectStepIndex === -1 && orderStepIndex === -1) {
+      return QueryPlan.Plan.make(processedSteps);
+    }
+
+    // Create a mutable copy of steps to modify.
+    const newSteps = [...processedSteps];
+
+    // Propagate the limit to the SelectStep if found.
+    if (selectStepIndex !== -1) {
+      const selectStep = newSteps[selectStepIndex] as QueryPlan.SelectStep;
+      newSteps[selectStepIndex] = {
+        ...selectStep,
+        limit: limitValue,
+      };
+    }
+
+    // Propagate the limit to the OrderStep if found.
+    if (orderStepIndex !== -1) {
+      const orderStep = newSteps[orderStepIndex] as QueryPlan.OrderStep;
+      newSteps[orderStepIndex] = {
+        ...orderStep,
+        limit: limitValue,
+      };
+    }
+
+    // Remove the LimitStep since limit is now propagated.
+    newSteps.splice(limitStepIndex, 1);
+
+    return QueryPlan.Plan.make(newSteps);
+  }
 }
 
 /**
@@ -441,6 +692,16 @@ type GenerationContext = {
    */
   selectionSpaces: readonly SpaceId[];
 
+  /**
+   * Whether to select from all queues in the spaces specified by selectionSpaces.
+   */
+  selectionAllQueuesFromSpaces: boolean;
+
+  /**
+   * Which queues to select from.
+   */
+  selectionQueues: readonly DXN.String[];
+
   /**
    * How to handle deleted objects.
    */
@@ -455,6 +716,8 @@ type GenerationContext = {
 const DEFAULT_CONTEXT: GenerationContext = {
   originalQuery: null,
   selectionSpaces: [],
+  selectionAllQueuesFromSpaces: false,
+  selectionQueues: [],
   deletedHandling: 'exclude',
   selectionInverted: false,
 };

package/src/space/admission-discovery-extension.ts

@@ -2,15 +2,15 @@
 // Copyright 2024 DXOS.org
 //
 
-import { scheduleTask, type Trigger } from '@dxos/async';
+import { type Trigger, scheduleTask } from '@dxos/async';
 import { Context } from '@dxos/context';
 import { ProtocolError } from '@dxos/protocols';
 import { schema } from '@dxos/protocols/proto';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
 import {
   type AdmissionDiscoveryService,
-  type GetAdmissionCredentialResponse,
   type GetAdmissionCredentialRequest,
+  type GetAdmissionCredentialResponse,
 } from '@dxos/protocols/proto/dxos/mesh/teleport';
 import { type ExtensionContext, RpcExtension } from '@dxos/teleport';
 
@@ -81,7 +81,7 @@ export class CredentialServerExtension extends RpcExtension<
         ): Promise<GetAdmissionCredentialResponse> => {
           const memberInfo = this._space.spaceState.members.get(request.memberKey);
           if (!memberInfo?.credential) {
-            throw new ProtocolError('Space member not found.', request);
+            throw new ProtocolError({ message: 'Space member not found.', context: { ...request } });
           }
           return { admissionCredential: memberInfo.credential };
         },

package/src/space/auth.ts

@@ -15,7 +15,7 @@ export type AuthProvider = (nonce: Uint8Array) => Promise<Uint8Array | undefined
 
 export type AuthVerifier = (nonce: Uint8Array, credential: Uint8Array) => Promise<boolean>;
 
-export type AuthExtensionParams = {
+export type AuthExtensionProps = {
   provider: AuthProvider;
   verifier: AuthVerifier;
   onAuthSuccess: () => void;
@@ -29,7 +29,7 @@ export class AuthExtension extends RpcExtension<Services, Services> {
     },
   });
 
-  constructor(private readonly _authParams: AuthExtensionParams) {
+  constructor(private readonly _authProps: AuthExtensionProps) {
     super({
       requested: {
         AuthService: schema.getService('dxos.mesh.teleport.auth.AuthService'),
@@ -46,7 +46,7 @@ export class AuthExtension extends RpcExtension<Services, Services> {
       AuthService: {
         authenticate: async ({ challenge }) => {
           try {
-            const credential = await this._authParams.provider(challenge);
+            const credential = await this._authProps.provider(challenge);
             if (!credential) {
               throw new Error('auth rejected');
             }
@@ -67,13 +67,13 @@ export class AuthExtension extends RpcExtension<Services, Services> {
         const challenge = randomBytes(32);
         const { credential } = await this.rpc.AuthService.authenticate({ challenge });
         invariant(credential?.length > 0, 'invalid credential');
-        const success = await this._authParams.verifier(challenge, credential);
+        const success = await this._authProps.verifier(challenge, credential);
         invariant(success, 'credential not verified');
-        runInContext(this._ctx, () => this._authParams.onAuthSuccess());
+        runInContext(this._ctx, () => this._authProps.onAuthSuccess());
       } catch (err) {
         log('auth failed', err);
         this.close();
-        this._authParams.onAuthFailure();
+        this._authProps.onAuthFailure();
       }
     });
   }

package/src/space/control-pipeline.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { describe, expect, test, onTestFinished } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { CredentialGenerator, createCredential } from '@dxos/credentials';
 import { FeedFactory, FeedStore } from '@dxos/feed-store';
@@ -11,13 +11,14 @@ import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
 import { AdmittedFeed } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { createStorage, StorageType } from '@dxos/random-access-storage';
+import { StorageType, createStorage } from '@dxos/random-access-storage';
 import { Timeframe } from '@dxos/timeframe';
 
-import { ControlPipeline } from './control-pipeline';
 import { valueEncoding } from '../common';
 import { MetadataStore } from '../metadata';
 
+import { ControlPipeline } from './control-pipeline';
+
 describe('space/control-pipeline', () => {
   test('admits feeds', async () => {
     const keyring = new Keyring();

package/src/space/control-pipeline.ts

@@ -2,14 +2,14 @@
 // Copyright 2022 DXOS.org
 //
 
-import { DeferredTask, sleepWithContext, trackLeaks } from '@dxos/async';
+import { DeferredTask, scheduleMicroTask, sleepWithContext, trackLeaks } from '@dxos/async';
 import { Context } from '@dxos/context';
 import {
-  SpaceStateMachine,
-  type SpaceState,
-  type MemberInfo,
-  type FeedInfo,
   type DelegateInvitationCredential,
+  type FeedInfo,
+  type MemberInfo,
+  type SpaceState,
+  SpaceStateMachine,
 } from '@dxos/credentials';
 import { type FeedWrapper } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
@@ -25,7 +25,7 @@ import { type AsyncCallback, Callback, tracer } from '@dxos/util';
 import { type MetadataStore } from '../metadata';
 import { Pipeline, type PipelineAccessor } from '../pipeline';
 
-export type ControlPipelineParams = {
+export type ControlPipelineProps = {
   spaceKey: PublicKey;
   genesisFeed: FeedWrapper<FeedMessage>;
   feedProvider: (feedKey: PublicKey) => Promise<FeedWrapper<FeedMessage>>;
@@ -70,7 +70,7 @@ export class ControlPipeline {
     await this._saveSnapshot();
   });
 
-  constructor({ spaceKey, genesisFeed, feedProvider, metadataStore }: ControlPipelineParams) {
+  constructor({ spaceKey, genesisFeed, feedProvider, metadataStore }: ControlPipelineProps) {
     this._spaceKey = spaceKey;
     this._metadata = metadataStore;
     this._pipeline = new Pipeline();
@@ -83,9 +83,12 @@ export class ControlPipeline {
 
       // TODO(burdon): Check not stopping.
       if (info.assertion.designation === AdmittedFeed.Designation.CONTROL && !info.key.equals(genesisFeed.key)) {
-        queueMicrotask(async () => {
+        scheduleMicroTask(this._ctx, async () => {
           try {
             const feed = await feedProvider(info.key);
+            if (this._ctx.disposed) {
+              return;
+            }
             if (!this._pipeline.hasFeed(feed.key)) {
               await this._pipeline.addFeed(feed);
             }

package/src/space/space-manager.browser.test.ts

@@ -2,7 +2,7 @@
 // Copyright 2022 DXOS.org
 //
 
-import { describe, test, onTestFinished } from 'vitest';
+import { describe, onTestFinished, test } from 'vitest';
 
 import { createStorage } from '@dxos/random-access-storage';
 

package/src/space/space-manager.ts

@@ -4,8 +4,8 @@
 
 import { type AutomergeUrl, parseAutomergeUrl } from '@automerge/automerge-repo';
 
-import { synchronized, trackLeaks, Trigger } from '@dxos/async';
-import { getCredentialAssertion, type DelegateInvitationCredential, type MemberInfo } from '@dxos/credentials';
+import { Trigger, synchronized, trackLeaks } from '@dxos/async';
+import { type DelegateInvitationCredential, type MemberInfo, getCredentialAssertion } from '@dxos/credentials';
 import { failUndefined } from '@dxos/debug';
 import { type FeedStore } from '@dxos/feed-store';
 import { PublicKey } from '@dxos/keys';
@@ -19,13 +19,14 @@ import { type Teleport } from '@dxos/teleport';
 import { type BlobStore } from '@dxos/teleport-extension-object-sync';
 import { ComplexMap } from '@dxos/util';
 
+import { createIdFromSpaceKey } from '../common/space-id';
+import { type MetadataStore } from '../metadata';
+
 import { CredentialRetrieverExtension } from './admission-discovery-extension';
 import { Space } from './space';
 import { SpaceProtocol, type SwarmIdentity } from './space-protocol';
-import { createIdFromSpaceKey } from '../common/space-id';
-import { type MetadataStore } from '../metadata';
 
-export type SpaceManagerParams = {
+export type SpaceManagerProps = {
   feedStore: FeedStore<FeedMessage>;
   networkManager: SwarmNetworkManager;
   metadataStore: MetadataStore;
@@ -35,7 +36,7 @@ export type SpaceManagerParams = {
   disableP2pReplication?: boolean;
 };
 
-export type ConstructSpaceParams = {
+export type ConstructSpaceProps = {
   metadata: SpaceMetadata;
   swarmIdentity: SwarmIdentity;
   memberKey: PublicKey;
@@ -48,7 +49,7 @@ export type ConstructSpaceParams = {
   onMemberRolesChanged: (member: MemberInfo[]) => Promise<void>;
 };
 
-export type RequestSpaceAdmissionCredentialParams = {
+export type RequestSpaceAdmissionCredentialProps = {
   spaceKey: PublicKey;
   identityKey: PublicKey;
   swarmIdentity: SwarmIdentity;
@@ -68,7 +69,7 @@ export class SpaceManager {
   private readonly _instanceId = PublicKey.random().toHex();
   private readonly _disableP2pReplication: boolean;
 
-  constructor({ feedStore, networkManager, metadataStore, blobStore, disableP2pReplication }: SpaceManagerParams) {
+  constructor({ feedStore, networkManager, metadataStore, blobStore, disableP2pReplication }: SpaceManagerProps) {
     // TODO(burdon): Assert.
     this._feedStore = feedStore;
     this._networkManager = networkManager;
@@ -98,7 +99,7 @@ export class SpaceManager {
     onDelegatedInvitationStatusChange,
     onMemberRolesChanged,
     memberKey,
-  }: ConstructSpaceParams): Promise<Space> {
+  }: ConstructSpaceProps): Promise<Space> {
     log.trace('dxos.echo.space-manager.construct-space', trace.begin({ id: this._instanceId }));
     log('constructing space...', { spaceKey: metadata.genesisFeedKey });
 
@@ -134,7 +135,7 @@ export class SpaceManager {
     return space;
   }
 
-  public async requestSpaceAdmissionCredential(params: RequestSpaceAdmissionCredentialParams): Promise<Credential> {
+  public async requestSpaceAdmissionCredential(params: RequestSpaceAdmissionCredentialProps): Promise<Credential> {
     const traceKey = 'dxos.echo.space-manager.request-space-admission';
     log.trace(traceKey, trace.begin({ id: this._instanceId }));
     log('requesting space admission credential...', { spaceKey: params.spaceKey });