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

package/src/db-host/query-service.ts

@@ -4,6 +4,7 @@
 
 import { getHeads } from '@automerge/automerge';
 import { type DocHandle, type DocumentId } from '@automerge/automerge-repo';
+import type * as SqlClient from '@effect/sql/SqlClient';
 import * as Schema from 'effect/Schema';
 
 import { DeferredTask, scheduleMicroTask, synchronized } from '@dxos/async';
@@ -11,6 +12,8 @@ import { Stream } from '@dxos/codec-protobuf/stream';
 import { Context, Resource } from '@dxos/context';
 import { raise } from '@dxos/debug';
 import { DatabaseDirectory, QueryAST } from '@dxos/echo-protocol';
+import { type RuntimeProvider } from '@dxos/effect';
+import { type IndexEngine } from '@dxos/index-core';
 import { type IdToHeads, type Indexer, type ObjectSnapshot } from '@dxos/indexing';
 import { log } from '@dxos/log';
 import { objectPointerCodec } from '@dxos/protocols';
@@ -28,8 +31,10 @@ import { QueryExecutor } from '../query';
 
 import type { SpaceStateManager } from './space-state-manager';
 
-export type QueryServiceParams = {
+export type QueryServiceProps = {
   indexer: Indexer;
+  indexer2?: IndexEngine;
+  runtime?: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
   automergeHost: AutomergeHost;
   spaceStateManager: SpaceStateManager;
 };
@@ -62,7 +67,7 @@ export class QueryServiceImpl extends Resource implements QueryService {
   private _updateQueries!: DeferredTask;
 
   // TODO(burdon): OK for options, but not params. Pass separately and type readonly here.
-  constructor(private readonly _params: QueryServiceParams) {
+  constructor(private readonly _params: QueryServiceProps) {
     super();
 
     trace.diagnostic({
@@ -155,6 +160,8 @@ export class QueryServiceImpl extends Resource implements QueryService {
     const queryEntry: ActiveQuery = {
       executor: new QueryExecutor({
         indexer: this._params.indexer,
+        indexer2: this._params.indexer2,
+        runtime: this._params.runtime,
         automergeHost: this._params.automergeHost,
         queryId: request.queryId ?? raise(new Error('query id required')),
         query: parsedQuery,
@@ -245,7 +252,13 @@ const createDocumentsIterator = (automergeHost: AutomergeHost) =>
           if (visited.has(urlString)) {
             continue;
           }
-          const linkHandle = await automergeHost.loadDoc<DatabaseDirectory>(Context.default(), urlString as DocumentId);
+          const linkHandle = await automergeHost.loadDoc<DatabaseDirectory>(
+            Context.default(),
+            urlString as DocumentId,
+            {
+              fetchFromNetwork: true,
+            },
+          );
           for await (const result of getObjectsFromHandle(linkHandle)) {
             yield result;
           }
@@ -256,7 +269,7 @@ const createDocumentsIterator = (automergeHost: AutomergeHost) =>
     }
 
     // TODO(mykola): Use list of roots instead of iterating over all handles.
-    for (const handle of Object.values(automergeHost.repo.handles)) {
+    for (const handle of Object.values(automergeHost.handles)) {
       if (visited.has(handle.documentId)) {
         continue;
       }

package/src/db-host/queue-data-source.ts

@@ -0,0 +1,132 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+
+import { RuntimeProvider } from '@dxos/effect';
+import { FeedCursor, type FeedStore } from '@dxos/feed';
+import { type DataSourceCursor, type IndexDataSource, type IndexerObject } from '@dxos/index-core';
+import { failedInvariant } from '@dxos/invariant';
+import type { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+
+export type QueueDataSourceOptions = {
+  feedStore: FeedStore;
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
+  /**
+   * Callback to get the list of space IDs that should be indexed.
+   */
+  getSpaceIds: () => SpaceId[];
+};
+
+export class QueueDataSource implements IndexDataSource {
+  readonly sourceName = 'queue';
+
+  private readonly _feedStore: FeedStore;
+  private readonly _runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
+  private readonly _getSpaceIds: () => SpaceId[];
+
+  constructor(options: QueueDataSourceOptions) {
+    this._feedStore = options.feedStore;
+    this._runtime = options.runtime;
+    this._getSpaceIds = options.getSpaceIds;
+  }
+
+  getChangedObjects(
+    cursors: DataSourceCursor[],
+    opts?: { limit?: number },
+  ): Effect.Effect<{ objects: IndexerObject[]; cursors: DataSourceCursor[] }> {
+    // For queue, the cursor is assumed to have:
+    // spaceId = set
+    // resourceId = null
+    // cursor = feed cursor
+
+    // We also add new cursors from all previously unindexed spaces.
+
+    return Effect.gen(this, function* () {
+      const objects: IndexerObject[] = [];
+      const updatedCursors: DataSourceCursor[] = [];
+
+      // Augment cursors with new spaces that haven't been indexed yet.
+      const existingSpaceIds = new Set(cursors.map((c) => c.spaceId).filter(Boolean));
+      const allSpaceIds = this._getSpaceIds();
+      const augmentedCursors = [...cursors];
+      for (const spaceId of allSpaceIds) {
+        if (!existingSpaceIds.has(spaceId)) {
+          // Add a new cursor for this space starting from the beginning.
+          // Empty string cursor means "start from beginning".
+          augmentedCursors.push({
+            spaceId,
+            resourceId: null,
+            cursor: '',
+          });
+        }
+      }
+
+      // Limit per call, but we might have multiple spaces.
+      // We should distribute limit or just fill up to limit.
+      let remainingLimit = opts?.limit ?? Infinity;
+
+      for (const cursor of augmentedCursors) {
+        if (remainingLimit <= 0) {
+          // Remaining cursors are not processed in this call.
+          updatedCursors.push(cursor);
+          continue;
+        }
+        if (!cursor.spaceId) {
+          // Ignore cursors without spaceId.
+          updatedCursors.push(cursor);
+          continue;
+        }
+
+        // Empty string cursor means "start from beginning".
+        const currentCursor =
+          typeof cursor.cursor === 'string' && cursor.cursor !== '' ? FeedCursor.make(cursor.cursor) : undefined;
+
+        try {
+          const result = yield* this._feedStore.query({
+            spaceId: cursor.spaceId,
+            cursor: currentCursor,
+            query: {
+              // Query all feeds in data namespace
+              feedNamespace: 'data',
+            },
+            limit: remainingLimit,
+          });
+
+          // Process blocks
+          for (const block of result.blocks) {
+            try {
+              const dataString = new TextDecoder().decode(block.data);
+              // TODO: Handle non-JSON data?
+              const data = JSON.parse(dataString);
+
+              objects.push({
+                spaceId: cursor.spaceId,
+                queueId: block.feedId ?? failedInvariant(),
+                documentId: null,
+                recordId: null,
+                data,
+              });
+            } catch (err) {
+              log.warn('Failed to parse block data for indexing', { spaceId: cursor.spaceId, err });
+            }
+          }
+
+          remainingLimit -= result.blocks.length;
+          updatedCursors.push({
+            spaceId: cursor.spaceId,
+            resourceId: null,
+            cursor: result.nextCursor,
+          });
+        } catch (error) {
+          log.error('Error querying queue for indexing', { spaceId: cursor.spaceId, error });
+        }
+      }
+
+      return { objects, cursors: updatedCursors };
+    }).pipe(RuntimeProvider.provide(this._runtime), Effect.withSpan('QueueDataSource.getChangedObjects'), Effect.orDie);
+  }
+}

package/src/db-host/queue-service.test.ts

@@ -0,0 +1,141 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as SqliteClient from '@effect/sql-sqlite-node/SqliteClient';
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { RuntimeProvider } from '@dxos/effect';
+import { FeedStore } from '@dxos/feed';
+import { ObjectId, SpaceId } from '@dxos/keys';
+
+import { LocalQueueServiceImpl } from './local-queue-service';
+
+const TestLayer = SqliteClient.layer({
+  filename: ':memory:',
+});
+
+describe('LocalQueueServiceImpl', () => {
+  it.effect('should insert and query items', () =>
+    Effect.gen(function* () {
+      const sql = yield* SqliteClient.SqliteClient;
+      const feedStore = new FeedStore({ localActorId: 'actor-id', assignPositions: true });
+      const runtime = yield* RuntimeProvider.currentRuntime<SqlClient.SqlClient>();
+      const service = new LocalQueueServiceImpl(runtime, feedStore);
+      yield* feedStore.migrate();
+
+      const spaceId = SpaceId.random();
+      const queueId = ObjectId.random();
+      const object1 = { id: 'obj1', data: 'test1' };
+      const object2 = { id: 'obj2', data: 'test2' };
+
+      yield* Effect.promise(() =>
+        service.insertIntoQueue({
+          subspaceTag: 'default',
+          spaceId,
+          queueId,
+          objects: [object1, object2],
+        }),
+      );
+
+      const result = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: { spaceId, queueIds: [queueId] },
+        }),
+      );
+      expect(result.objects?.[0]).toMatchObject(object1);
+      expect(result.objects?.[1]).toMatchObject(object2);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should delete items', () =>
+    Effect.gen(function* () {
+      const sql = yield* SqliteClient.SqliteClient;
+      const runtime = Effect.succeed(yield* Effect.runtime<any>());
+      const feedStore = new FeedStore({ localActorId: 'actor-id', assignPositions: true });
+      const service = new LocalQueueServiceImpl(runtime, feedStore);
+      yield* feedStore.migrate();
+
+      const spaceId = SpaceId.random();
+      const queueId = ObjectId.random();
+      const object1Id = ObjectId.random();
+      const object1 = { id: object1Id, data: 'test1' };
+
+      yield* Effect.promise(() =>
+        service.insertIntoQueue({
+          subspaceTag: 'default',
+          spaceId,
+          queueId,
+          objects: [object1],
+        }),
+      );
+      yield* Effect.promise(() =>
+        service.deleteFromQueue({
+          subspaceTag: 'default',
+          spaceId,
+          queueId,
+          objectIds: [object1Id],
+        }),
+      );
+
+      const result = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: { spaceId, queueIds: [queueId] },
+        }),
+      );
+      expect(result.objects).toHaveLength(2);
+      expect(result.objects?.[1]).toMatchObject({ id: object1Id, '@deleted': true });
+    }).pipe(Effect.provide(TestLayer)),
+  );
+
+  it.effect('should support pagination', () =>
+    Effect.gen(function* () {
+      const sql = yield* SqliteClient.SqliteClient;
+      const runtime = Effect.succeed(yield* Effect.runtime<any>());
+      const feedStore = new FeedStore({ localActorId: 'actor-id', assignPositions: true });
+      yield* feedStore.migrate();
+      const service = new LocalQueueServiceImpl(runtime, feedStore);
+      const spaceId = 'space-1' as SpaceId;
+      const queueId = ObjectId.random();
+
+      // Insert 10 items
+      const items = Array.from({ length: 10 }, (_, i) => ({ id: `obj${i}`, data: `test${i}` }));
+      yield* Effect.promise(() =>
+        service.insertIntoQueue({
+          subspaceTag: 'default',
+          spaceId,
+          queueId,
+          objects: items,
+        }),
+      );
+
+      // Query first 5
+      const page1 = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: { spaceId, queueIds: [queueId], limit: 5 },
+        }),
+      );
+      expect(page1.objects).toHaveLength(5);
+      expect(page1.objects?.[0]).toMatchObject(items[0]);
+      expect(page1.objects?.[4]).toMatchObject(items[4]);
+      expect(page1.nextCursor).toBeDefined();
+
+      // Query next 5
+      const page2 = yield* Effect.promise(() =>
+        service.queryQueue({
+          query: {
+            spaceId,
+            queueIds: [queueId],
+            limit: 5,
+            after: page1.nextCursor!,
+          },
+        }),
+      );
+      expect(page2.objects).toHaveLength(5);
+      expect(page2.objects?.[0]).toMatchObject(items[5]);
+      expect(page2.objects?.[4]).toMatchObject(items[9]);
+    }).pipe(Effect.provide(TestLayer)),
+  );
+});

package/src/db-host/space-state-manager.ts

@@ -32,6 +32,10 @@ export class SpaceStateManager extends Resource {
     return this._roots;
   }
 
+  get spaceIds(): SpaceId[] {
+    return Array.from(this._rootBySpace.keys());
+  }
+
   getRootByDocumentId(documentId: DocumentId): DatabaseRoot | undefined {
     return this._roots.get(documentId);
   }

package/src/db-host/stub.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type {
+  DeleteFromQueueRequest,
+  InsertIntoQueueRequest,
+  QueryQueueRequest,
+  QueueQueryResult,
+  QueueService,
+} from '@dxos/protocols/proto/dxos/client/services';
+
+/**
+ * Stub implementation for when Edge is not available.
+ */
+export class QueueServiceStub implements QueueService {
+  queryQueue(request: QueryQueueRequest): Promise<QueueQueryResult> {
+    throw new Error('Not available.');
+  }
+
+  insertIntoQueue(request: InsertIntoQueueRequest): Promise<void> {
+    throw new Error('Not available.');
+  }
+
+  deleteFromQueue(request: DeleteFromQueueRequest): Promise<void> {
+    throw new Error('Not available.');
+  }
+}

package/src/edge/echo-edge-replicator.ts

@@ -17,6 +17,7 @@ import {
   type AutomergeProtocolMessage,
   DocumentCodec,
   EdgeService,
+  type ErrorProtocolMessage,
   type ExportBundleRequest,
   type ImportBundleRequest,
   type PeerId,
@@ -32,8 +33,8 @@ import {
   type EchoReplicator,
   type EchoReplicatorContext,
   type ReplicatorConnection,
-  type ShouldAdvertiseParams,
-  type ShouldSyncCollectionParams,
+  type ShouldAdvertiseProps,
+  type ShouldSyncCollectionProps,
   getSpaceIdFromCollectionId,
 } from '../automerge';
 
@@ -46,7 +47,7 @@ const INITIAL_RESTART_DELAY = 500;
 const RESTART_DELAY_JITTER = 250;
 const MAX_RESTART_DELAY = 5000;
 
-export type EchoEdgeReplicatorParams = {
+export type EchoEdgeReplicatorProps = {
   edgeConnection: EdgeConnection;
   edgeHttpClient: EdgeHttpClient;
   disableSharePolicy?: boolean;
@@ -63,7 +64,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
   private _connections = new Map<SpaceId, EdgeReplicatorConnection>();
   private _sharePolicyEnabled = true;
 
-  constructor({ edgeConnection, edgeHttpClient, disableSharePolicy }: EchoEdgeReplicatorParams) {
+  constructor({ edgeConnection, edgeHttpClient, disableSharePolicy }: EchoEdgeReplicatorProps) {
     this._edgeConnection = edgeConnection;
     this._edgeHttpClient = edgeHttpClient;
     this._sharePolicyEnabled = !disableSharePolicy;
@@ -107,6 +108,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
   }
 
   async connectToSpace(spaceId: SpaceId): Promise<void> {
+    log('connectToSpace', { spaceId });
     using _guard = await this._mutex.acquire();
 
     if (this._connectedSpaces.has(spaceId)) {
@@ -190,7 +192,7 @@ export class EchoEdgeReplicator implements EchoReplicator {
   }
 }
 
-type EdgeReplicatorConnectionsParams = {
+type EdgeReplicatorConnectionsProps = {
   edgeConnection: EdgeConnection;
   edgeHttpClient: EdgeHttpClient;
   spaceId: SpaceId;
@@ -237,7 +239,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     onRemoteConnected,
     onRemoteDisconnected,
     onRestartRequested,
-  }: EdgeReplicatorConnectionsParams) {
+  }: EdgeReplicatorConnectionsProps) {
     super();
     this._edgeConnection = edgeConnection;
     this._edgeHttpClient = edgeHttpClient;
@@ -311,7 +313,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return this._remotePeerId;
   }
 
-  async shouldAdvertise(params: ShouldAdvertiseParams): Promise<boolean> {
+  async shouldAdvertise(params: ShouldAdvertiseProps): Promise<boolean> {
     if (!this._sharedPolicyEnabled) {
       return true;
     }
@@ -336,7 +338,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     return spaceId === this._spaceId;
   }
 
-  shouldSyncCollection(params: ShouldSyncCollectionParams): boolean {
+  shouldSyncCollection(params: ShouldSyncCollectionProps): boolean {
     if (!this._sharedPolicyEnabled) {
       return true;
     }
@@ -387,6 +389,7 @@ class EdgeReplicatorConnection extends Resource implements ReplicatorConnection
     // AutomergeReplicator might return a Forbidden error if the credentials are not yet replicated.
     // We restart the connection with some delay to account for that.
     if (isErrorMessage(message)) {
+      log.verbose('stream error', { error: (message as ErrorProtocolMessage).message });
       this._onRestartRequested();
       return;
     }
@@ -442,6 +445,7 @@ const getMessageInfo = (msg: AutomergeProtocolMessage) => {
   return {
     type: msg.type,
     documentId: 'documentId' in msg ? msg.documentId : undefined,
+    collectionId: 'collectionId' in msg ? msg.collectionId : undefined,
     have,
     heads,
     need,

package/src/filter/filter-match.test.ts

@@ -4,8 +4,8 @@
 
 import { describe, expect, test } from 'vitest';
 
-import { Filter } from '@dxos/echo';
-import { EXPANDO_TYPENAME, Expando, Ref } from '@dxos/echo/internal';
+import { Filter, Ref } from '@dxos/echo';
+import { TestSchema } from '@dxos/echo/testing';
 import { ObjectStructure } from '@dxos/echo-protocol';
 import { DXN, ObjectId, SpaceId } from '@dxos/keys';
 
@@ -23,32 +23,34 @@ describe('filterMatch', () => {
   });
 
   test('properties', () => {
-    expect(filterMatchObject(Filter.type(Expando, { title: 'test' }).ast, OBJECT_1)).to.be.true;
-    expect(filterMatchObject(Filter.type(Expando, { value: 100 }).ast, OBJECT_1)).to.be.true;
-    expect(filterMatchObject(Filter.type(Expando, { complete: false }).ast, OBJECT_1)).to.be.false;
-    expect(filterMatchObject(Filter.type(Expando, { missing: undefined }).ast, OBJECT_1)).to.be.true;
-    expect(filterMatchObject(Filter.type(Expando, { properties: { subject: 'test' } }).ast, OBJECT_1)).to.be.true;
-    expect(filterMatchObject(Filter.type(Expando, { array: Filter.contains('two') }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { title: 'test' }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { value: 100 }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { complete: false }).ast, OBJECT_1)).to.be.false;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { missing: undefined }).ast, OBJECT_1)).to.be.true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { properties: { subject: 'test' } }).ast, OBJECT_1)).to.be
+      .true;
+    expect(filterMatchObject(Filter.type(TestSchema.Expando, { array: Filter.contains('two') }).ast, OBJECT_1)).to.be
+      .true;
   });
 
   test('and', () => {
-    const filter1 = Filter.type(Expando, { title: 'test' });
-    const filter2 = Filter.type(Expando, { value: 100 });
-    const filter3 = Filter.type(Expando, { complete: true });
+    const filter1 = Filter.type(TestSchema.Expando, { title: 'test' });
+    const filter2 = Filter.type(TestSchema.Expando, { value: 100 });
+    const filter3 = Filter.type(TestSchema.Expando, { complete: true });
 
     expect(filterMatchObject(Filter.and(filter1, filter2, filter3).ast, OBJECT_1)).to.be.true;
   });
 
   test('or', () => {
-    const filter1 = Filter.type(Expando, { value: 200 });
-    const filter2 = Filter.type(Expando, { title: 'test' });
-    const filter3 = Filter.type(Expando, { complete: false });
+    const filter1 = Filter.type(TestSchema.Expando, { value: 200 });
+    const filter2 = Filter.type(TestSchema.Expando, { title: 'test' });
+    const filter3 = Filter.type(TestSchema.Expando, { complete: false });
 
     expect(filterMatchObject(Filter.or(filter1, filter2, filter3).ast, OBJECT_1)).to.be.true;
   });
 
   test('not', () => {
-    const filter1 = Filter.type(Expando, { title: 'test' });
+    const filter1 = Filter.type(TestSchema.Expando, { title: 'test' });
     const filter2 = Filter.not(filter1);
 
     expect(filterMatchObject(filter1.ast, OBJECT_1)).to.be.true;
@@ -56,30 +58,34 @@ describe('filterMatch', () => {
   });
 
   test('contains', () => {
-    expect(filterMatchObject(Filter.type(Expando, { properties: { label: Filter.contains('test') } }).ast, OBJECT_1)).to
-      .be.true;
     expect(
       filterMatchObject(
-        Filter.type(Expando, { fields: Filter.contains({ label: 'label', value: 'test' }) }).ast,
+        Filter.type(TestSchema.Expando, { properties: { label: Filter.contains('test') } }).ast,
+        OBJECT_1,
+      ),
+    ).to.be.true;
+    expect(
+      filterMatchObject(
+        Filter.type(TestSchema.Expando, { fields: Filter.contains({ label: 'label', value: 'test' }) }).ast,
         OBJECT_1,
       ),
     ).to.be.true;
   });
 
   test('complex', () => {
-    const filter1 = Filter.type(Expando, { title: 'bad' });
-    const filter2 = Filter.type(Expando, { value: 0 });
+    const filter1 = Filter.type(TestSchema.Expando, { title: 'bad' });
+    const filter2 = Filter.type(TestSchema.Expando, { value: 0 });
     expect(filterMatchObject(Filter.not(Filter.or(filter1, filter2)).ast, OBJECT_1)).to.be.true;
   });
 
   test('ids', () => {
-    const filter = Filter.ids(OBJECT_1.id);
+    const filter = Filter.id(OBJECT_1.id);
     expect(filterMatchObject(filter.ast, OBJECT_1)).to.be.true;
     expect(filterMatchObject(filter.ast, OBJECT_2)).to.be.false;
   });
 
   test('refs', () => {
-    const filter = Filter.type(Expando, { parent: Ref.fromDXN(DXN.fromLocalObjectId(OBJECT_1.id)) });
+    const filter = Filter.type(TestSchema.Expando, { parent: Ref.fromDXN(DXN.fromLocalObjectId(OBJECT_1.id)) });
     expect(filterMatchObject(filter.ast, OBJECT_1)).to.be.false;
     expect(filterMatchObject(filter.ast, OBJECT_2)).to.be.false;
     expect(filterMatchObject(filter.ast, OBJECT_3)).to.be.true;
@@ -90,7 +96,7 @@ const OBJECT_1: MatchedObject = {
   id: ObjectId.make('01JVS9YYT5VMVJW0GGTM1YHCCH'),
   spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
   doc: ObjectStructure.makeObject({
-    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    type: DXN.fromTypenameAndVersion(TestSchema.Expando.typename, '0.1.0').toString(),
     data: {
       title: 'test',
       value: 100,
@@ -106,7 +112,7 @@ const OBJECT_2: MatchedObject = {
   id: ObjectId.make('01JT5TD6K9FFJ3VNM5FGMS5C0Q'),
   spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
   doc: ObjectStructure.makeObject({
-    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    type: DXN.fromTypenameAndVersion(TestSchema.Expando.typename, '0.1.0').toString(),
     data: { title: 'test', value: 100, complete: true },
     deleted: true,
   }),
@@ -116,7 +122,7 @@ const OBJECT_3: MatchedObject = {
   id: ObjectId.make('01JT5TD6K9FFJ3VNM5FGMS5C0Q'),
   spaceId: SpaceId.make('B2NJDFNVZIW77OQSXUBNAD7BUMBD3G5PO'),
   doc: ObjectStructure.makeObject({
-    type: DXN.fromTypenameAndVersion(EXPANDO_TYPENAME, '0.1.0').toString(),
+    type: DXN.fromTypenameAndVersion(TestSchema.Expando.typename, '0.1.0').toString(),
     data: { title: 'test', value: 100, complete: true, parent: { '/': DXN.fromLocalObjectId(OBJECT_1.id).toString() } },
   }),
 };

package/src/filter/filter-match.ts

@@ -2,8 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { ATTR_META, EXPANDO_TYPENAME, type ObjectJSON } from '@dxos/echo/internal';
-import { ObjectStructure, type QueryAST, decodeReference, isEncodedReference } from '@dxos/echo-protocol';
+import { ATTR_META, type ObjectJSON } from '@dxos/echo/internal';
+import { EncodedReference, ObjectStructure, type QueryAST, isEncodedReference } from '@dxos/echo-protocol';
 import { DXN, type ObjectId, type SpaceId } from '@dxos/keys';
 
 export type MatchedObject = {
@@ -23,11 +23,8 @@ export const filterMatchObject = (filter: QueryAST.Filter, obj: MatchedObject):
       if (filter.typename !== null) {
         // TODO(dmaretskyi): `system` is missing in some cases.
         if (!obj.doc.system?.type?.['/']) {
-          // Objects with no type are considered to be expando objects.
-          const expectedDXN = DXN.parse(filter.typename).asTypeDXN();
-          if (expectedDXN?.type !== EXPANDO_TYPENAME) {
-            return false;
-          }
+          // Objects with no type are deprecated.
+          return false;
         } else {
           const actualDXN = DXN.parse(obj.doc.system.type['/']);
           const expectedDXN = DXN.parse(filter.typename);
@@ -100,11 +97,8 @@ export const filterMatchObjectJSON = (filter: QueryAST.Filter, obj: ObjectJSON):
       if (filter.typename !== null) {
         // TODO(dmaretskyi): `system` is missing in some cases.
         if (!obj['@type']) {
-          // Objects with no type are considered to be expando objects
-          const expectedDXN = DXN.parse(filter.typename).asTypeDXN();
-          if (expectedDXN?.type !== EXPANDO_TYPENAME) {
-            return false;
-          }
+          // Objects with no type are deprecated.
+          return false;
         } else {
           const actualDXN = DXN.parse(obj['@type']);
           const expectedDXN = DXN.parse(filter.typename);
@@ -151,8 +145,8 @@ export const filterMatchObjectJSON = (filter: QueryAST.Filter, obj: ObjectJSON):
       return tags.some((tag) => tag === filter.tag);
     }
 
+    // TODO: Implement text search.
     case 'text-search': {
-      // TODO: Implement text search
       return false;
     }
 
@@ -219,7 +213,7 @@ export const filterMatchValue = (filter: QueryAST.Filter, value: unknown): boole
             if (!isEncodedReference(value)) {
               return false;
             }
-            return DXN.equals(decodeReference(value).toDXN(), decodeReference(compareValue).toDXN());
+            return DXN.equals(EncodedReference.toDXN(value), EncodedReference.toDXN(compareValue));
           }
           return value === compareValue;
         case 'neq':

package/src/metadata/metadata-store.ts

@@ -91,14 +91,17 @@ export class MetadataStore {
       log('loaded', { size: dataSize, checksum, name: file.filename });
 
       if (fileLength < dataSize + 8) {
-        throw new DataCorruptionError('Metadata size is smaller than expected.', { fileLength, dataSize });
+        throw new DataCorruptionError({
+          message: 'Metadata size is smaller than expected.',
+          context: { fileLength, dataSize },
+        });
       }
 
       const data = await file.read(8, dataSize);
 
       const calculatedChecksum = CRC32.buf(data);
       if (calculatedChecksum !== checksum) {
-        throw new DataCorruptionError('Metadata checksum is invalid.');
+        throw new DataCorruptionError({ message: 'Metadata checksum is invalid.' });
       }
 
       return codec.decode(data);