@dxos/echo-pipeline 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/src/query/query-planner.ts

@@ -37,6 +37,7 @@ export class QueryPlanner {
     plan = this._optimizeEmptyFilters(plan);
     plan = this._optimizeSoloUnions(plan);
     plan = this._ensureOrderStep(plan);
+    plan = this._optimizeLimits(plan);
     return plan;
   }
 
@@ -62,6 +63,8 @@ export class QueryPlanner {
         return this._generateSetDifferenceClause(query, context);
       case 'order':
         return this._generateOrderClause(query, context);
+      case 'limit':
+        return this._generateLimitClause(query, context);
       default:
         throw new QueryError({
           message: `Unsupported query type: ${(query as any).type}`,
@@ -77,6 +80,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;
     }
@@ -121,6 +130,8 @@ export class QueryPlanner {
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'IdSelector',
                 objectIds: filter.id,
@@ -137,6 +148,8 @@ export class QueryPlanner {
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'TypeSelector',
                 typename: [filter.typename as DXN.String],
@@ -144,9 +157,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 {
@@ -154,6 +168,8 @@ export class QueryPlanner {
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'WildcardSelector',
               },
@@ -173,6 +189,8 @@ export class QueryPlanner {
           {
             _tag: 'SelectStep',
             spaces: context.selectionSpaces,
+            allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+            queues: context.selectionQueues,
             selector: {
               _tag: 'WildcardSelector',
             },
@@ -191,10 +209,13 @@ export class QueryPlanner {
           {
             _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),
@@ -229,6 +250,8 @@ export class QueryPlanner {
             {
               _tag: 'SelectStep',
               spaces: context.selectionSpaces,
+              allQueuesFromSpaces: context.selectionAllQueuesFromSpaces,
+              queues: context.selectionQueues,
               selector: {
                 _tag: 'TypeSelector',
                 typename: typenames as DXN.String[],
@@ -236,6 +259,10 @@ export class QueryPlanner {
               },
             },
             ...this._generateDeletedHandlingSteps(context),
+            {
+              _tag: 'FilterStep',
+              filter: { ...filter },
+            },
           ]);
         } else {
           throw new QueryError({ message: 'Query too complex', context: { query: context.originalQuery } });
@@ -321,7 +348,7 @@ export class QueryPlanner {
         traversal: {
           _tag: 'ReferenceTraversal',
           direction: 'incoming',
-          property: query.property,
+          property: query.property ?? null,
         },
       },
       ...this._generateDeletedHandlingSteps(context),
@@ -471,29 +498,164 @@ export class QueryPlanner {
     ]);
   }
 
+  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 append natural order to the end.
+  //   - 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 = plan.steps.length - 1; i >= 0; i--) {
-      const step = plan.steps[i];
+    for (let i = processedPlan.steps.length - 1; i >= 0; i--) {
+      const step = processedPlan.steps[i];
       if (step._tag === 'OrderStep') {
-        return plan;
+        return processedPlan;
       }
       if (OBJECT_SET_CHANGERS.has(step._tag)) {
         break;
       }
     }
 
-    return QueryPlan.Plan.make([
-      ...plan.steps,
-      {
-        _tag: 'OrderStep',
-        order: [Order.natural.ast],
-      },
-    ]);
+    // 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);
   }
 }
 
@@ -511,6 +673,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.
    */
@@ -525,6 +697,8 @@ type GenerationContext = {
 const DEFAULT_CONTEXT: GenerationContext = {
   originalQuery: null,
   selectionSpaces: [],
+  selectionAllQueuesFromSpaces: false,
+  selectionQueues: [],
   deletedHandling: 'exclude',
   selectionInverted: false,
 };

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

@@ -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.ts

@@ -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();

package/src/space/space-manager.ts

@@ -26,7 +26,7 @@ import { CredentialRetrieverExtension } from './admission-discovery-extension';
 import { Space } from './space';
 import { SpaceProtocol, type SwarmIdentity } from './space-protocol';
 
-export type SpaceManagerParams = {
+export type SpaceManagerProps = {
   feedStore: FeedStore<FeedMessage>;
   networkManager: SwarmNetworkManager;
   metadataStore: MetadataStore;
@@ -36,7 +36,7 @@ export type SpaceManagerParams = {
   disableP2pReplication?: boolean;
 };
 
-export type ConstructSpaceParams = {
+export type ConstructSpaceProps = {
   metadata: SpaceMetadata;
   swarmIdentity: SwarmIdentity;
   memberKey: PublicKey;
@@ -49,7 +49,7 @@ export type ConstructSpaceParams = {
   onMemberRolesChanged: (member: MemberInfo[]) => Promise<void>;
 };
 
-export type RequestSpaceAdmissionCredentialParams = {
+export type RequestSpaceAdmissionCredentialProps = {
   spaceKey: PublicKey;
   identityKey: PublicKey;
   swarmIdentity: SwarmIdentity;
@@ -69,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;
@@ -99,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 });
 
@@ -135,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 });

package/src/space/space-protocol.ts

@@ -12,7 +12,7 @@ import {
   type SwarmConnection,
   type SwarmNetworkManager,
   type WireProtocol,
-  type WireProtocolParams,
+  type WireProtocolProps,
   type WireProtocolProvider,
 } from '@dxos/network-manager';
 import type { FeedMessage } from '@dxos/protocols/proto/dxos/echo/feed';
@@ -176,16 +176,16 @@ export class SpaceProtocol {
   }
 
   private _createProtocolProvider(credentials: Uint8Array | undefined): WireProtocolProvider {
-    return (wireParams) => {
+    return (wireProps) => {
       const session = new SpaceProtocolSession({
-        wireParams,
+        wireProps,
         swarmIdentity: this._swarmIdentity,
         onSessionAuth: this._onSessionAuth,
         onAuthFailure: this._onAuthFailure,
         blobSync: this.blobSync,
         disableP2pReplication: this._disableP2pReplication,
       });
-      this._sessions.set(wireParams.remotePeerId, session);
+      this._sessions.set(wireProps.remotePeerId, session);
 
       for (const feed of this._feeds) {
         session.replicator.addFeed(feed);
@@ -196,8 +196,8 @@ export class SpaceProtocol {
   }
 }
 
-export type SpaceProtocolSessionParams = {
-  wireParams: WireProtocolParams;
+export type SpaceProtocolSessionProps = {
+  wireProps: WireProtocolProps;
   swarmIdentity: SwarmIdentity;
 
   blobSync: BlobSync;
@@ -225,7 +225,7 @@ export enum AuthStatus {
  */
 export class SpaceProtocolSession implements WireProtocol {
   @logInfo
-  private readonly _wireParams: WireProtocolParams;
+  private readonly _wireProps: WireProtocolProps;
 
   private readonly _disableP2pReplication: boolean;
 
@@ -252,20 +252,20 @@ export class SpaceProtocolSession implements WireProtocol {
 
   // TODO(dmaretskyi): Allow to pass in extra extensions.
   constructor({
-    wireParams,
+    wireProps,
     swarmIdentity,
     onSessionAuth,
     onAuthFailure,
     blobSync,
     disableP2pReplication,
-  }: SpaceProtocolSessionParams) {
-    this._wireParams = wireParams;
+  }: SpaceProtocolSessionProps) {
+    this._wireProps = wireProps;
     this._swarmIdentity = swarmIdentity;
     this._onSessionAuth = onSessionAuth;
     this._onAuthFailure = onAuthFailure;
     this._blobSync = blobSync;
 
-    this._teleport = new Teleport(wireParams);
+    this._teleport = new Teleport(wireProps);
 
     this._disableP2pReplication = disableP2pReplication ?? false;
   }

package/src/space/space.ts

@@ -24,7 +24,7 @@ import { type SpaceProtocol } from './space-protocol';
 // TODO(burdon): Factor out?
 type FeedProvider = (feedKey: PublicKey, opts?: FeedOptions) => Promise<FeedWrapper<FeedMessage>>;
 
-export type SpaceParams = {
+export type SpaceProps = {
   id: SpaceId;
   spaceKey: PublicKey;
   protocol: SpaceProtocol;
@@ -40,7 +40,7 @@ export type SpaceParams = {
   onMemberRolesChanged: (member: MemberInfo[]) => Promise<void>;
 };
 
-export type CreatePipelineParams = {
+export type CreatePipelineProps = {
   start: Timeframe;
   // designation: AdmittedFeed.Designation;
 };
@@ -68,7 +68,7 @@ export class Space extends Resource {
   private _controlFeed?: FeedWrapper<FeedMessage>;
   private _dataFeed?: FeedWrapper<FeedMessage>;
 
-  constructor(params: SpaceParams) {
+  constructor(params: SpaceProps) {
     super();
     invariant(params.spaceKey && params.feedProvider);
     this._id = params.id;

package/src/testing/index.ts

@@ -7,5 +7,3 @@ export * from './test-agent-builder';
 export * from './test-feed-builder';
 export * from './test-network-adapter';
 export * from './test-replicator';
-export * as TestSchema from './test-schema';
-export * as TestData from './test-data';

package/src/testing/test-network-adapter.ts

@@ -11,12 +11,25 @@ import { log } from '@dxos/log';
 export type TestConnectionStateProvider = () => 'on' | 'off';
 
 export class TestAdapter extends NetworkAdapter {
-  static createPair(connectionStateProvider: TestConnectionStateProvider = () => 'on'): TestAdapter[] {
+  static createPair(
+    connectionStateProvider: TestConnectionStateProvider = () => 'on',
+    onMessage?: (message: Message) => void,
+  ): TestAdapter[] {
     const adapter1: TestAdapter = new TestAdapter({
-      send: (message: Message) => connectionStateProvider() === 'on' && sleep(10).then(() => adapter2.receive(message)),
+      send: (message: Message) => {
+        onMessage?.(message);
+        if (connectionStateProvider() === 'on') {
+          void sleep(10).then(() => adapter2.receive(message));
+        }
+      },
     });
     const adapter2: TestAdapter = new TestAdapter({
-      send: (message: Message) => connectionStateProvider() === 'on' && sleep(10).then(() => adapter1.receive(message)),
+      send: (message: Message) => {
+        onMessage?.(message);
+        if (connectionStateProvider() === 'on') {
+          void sleep(10).then(() => adapter1.receive(message));
+        }
+      },
     });
 
     return [adapter1, adapter2];

package/src/testing/test-replicator.ts

@@ -13,8 +13,8 @@ import type {
   EchoReplicator,
   EchoReplicatorContext,
   ReplicatorConnection,
-  ShouldAdvertiseParams,
-  ShouldSyncCollectionParams,
+  ShouldAdvertiseProps,
+  ShouldSyncCollectionProps,
 } from '../automerge';
 
 export type TestReplicatorNetworkOptions = {
@@ -30,7 +30,7 @@ export class TestReplicationNetwork extends Resource {
     this._latency = options.latency;
   }
 
-  protected override async _close(ctx: Context): Promise<void> {
+  protected override async _close(_ctx: Context): Promise<void> {
     for (const replicator of this._replicators) {
       for (const connection of replicator.connections) {
         void connection.writable.abort();
@@ -115,13 +115,13 @@ export class TestReplicationNetwork extends Resource {
   }
 }
 
-type TestReplicatorParams = {
+type TestReplicatorProps = {
   onConnect: () => Promise<void>;
   onDisconnect: () => Promise<void>;
 };
 
 export class TestReplicator implements EchoReplicator {
-  constructor(private readonly _params: TestReplicatorParams) {}
+  constructor(private readonly _params: TestReplicatorProps) {}
 
   public connected = false;
   public context: EchoReplicatorContext | undefined = undefined;
@@ -167,11 +167,11 @@ export class TestReplicatorConnection implements ReplicatorConnection {
     return false;
   }
 
-  async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(_params: ShouldAdvertiseProps): Promise<boolean> {
     return true;
   }
 
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(_params: ShouldSyncCollectionProps): boolean {
     return true;
   }
 }
@@ -194,5 +194,6 @@ export const brokenAutomergeReplicatorFactory: AutomergeReplicatorFactory = (par
   params[1]!.onSyncMessage = () => {
     throw new Error();
   };
+
   return testAutomergeReplicatorFactory(params);
 };

package/src/util.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type DatabaseDirectory, ObjectStructure, decodeReference } from '@dxos/echo-protocol';
+import { type DatabaseDirectory, EncodedReference, ObjectStructure } from '@dxos/echo-protocol';
 
 /**
  * Assumes properties are at root.
@@ -14,8 +14,12 @@ export const findInlineObjectOfType = (
   for (const id in spaceDoc.objects ?? {}) {
     const obj = spaceDoc.objects![id];
     const objType = ObjectStructure.getTypeReference(obj);
-    if (objType && decodeReference(objType).objectId === typename) {
-      return [id, obj];
+    if (objType) {
+      const typeDXN = EncodedReference.toDXN(objType);
+      const typeDXNInfo = typeDXN.asTypeDXN();
+      if (typeDXNInfo?.type === typename) {
+        return [id, obj];
+      }
     }
   }
 

package/dist/lib/browser/chunk-CGS2ULMK.mjs

@@ -1,11 +0,0 @@
-import "@dxos/node-std/globals";
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-export {
-  __export
-};
-//# sourceMappingURL=chunk-CGS2ULMK.mjs.map

package/dist/lib/browser/chunk-CGS2ULMK.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": [],
-  "sourcesContent": [],
-  "mappings": "",
-  "names": []
-}