@dxos/index-core 0.0.0 → 0.8.4-main.03d5cd7b56

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@dxos/index-core",
-  "version": "0.0.0",
+  "version": "0.8.4-main.03d5cd7b56",
   "description": "Indexing core.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
   "sideEffects": false,
@@ -12,8 +16,7 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     }
   },
   "files": [
@@ -21,23 +24,24 @@
     "src"
   ],
   "dependencies": {
-    "@dxos/async": "",
-    "@dxos/context": "",
-    "@dxos/debug": "",
-    "@dxos/echo": "",
-    "@dxos/echo-protocol": "",
-    "@dxos/effect": "",
-    "@dxos/invariant": "",
-    "@dxos/keys": "",
-    "@dxos/log": "",
-    "@effect/cli": "0.72.1",
-    "@effect/experimental": "0.57.11",
-    "@effect/platform": "0.93.6",
-    "@effect/sql": "0.48.6",
-    "effect": "3.19.11"
+    "@effect/cli": "0.73.2",
+    "@effect/experimental": "0.58.0",
+    "@effect/platform": "0.94.4",
+    "@effect/sql": "0.49.0",
+    "effect": "3.20.0",
+    "@dxos/async": "0.8.4-main.03d5cd7b56",
+    "@dxos/context": "0.8.4-main.03d5cd7b56",
+    "@dxos/debug": "0.8.4-main.03d5cd7b56",
+    "@dxos/echo-protocol": "0.8.4-main.03d5cd7b56",
+    "@dxos/invariant": "0.8.4-main.03d5cd7b56",
+    "@dxos/effect": "0.8.4-main.03d5cd7b56",
+    "@dxos/keys": "0.8.4-main.03d5cd7b56",
+    "@dxos/log": "0.8.4-main.03d5cd7b56",
+    "@dxos/sql-sqlite": "0.8.4-main.03d5cd7b56",
+    "@dxos/echo": "0.8.4-main.03d5cd7b56"
   },
   "devDependencies": {
-    "@effect/sql-sqlite-node": "0.49.1"
+    "@effect/sql-sqlite-node": "0.50.1"
   },
   "publishConfig": {
     "access": "public"

package/src/index-engine.test.ts

@@ -8,11 +8,13 @@ import { describe, expect, it } from '@effect/vitest';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
 
+import { Context } from '@dxos/context';
 import { ATTR_TYPE } from '@dxos/echo/internal';
 import { invariant } from '@dxos/invariant';
 import { DXN, ObjectId, SpaceId } from '@dxos/keys';
+import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
 
-import { type DataSourceCursor, type IndexDataSource, IndexEngine } from './index-engine';
+import { type DataSourceCursor, type IndexDataSource, IndexEngine, type IndexingResult } from './index-engine';
 import { type IndexCursor, IndexTracker } from './index-tracker';
 import { FtsIndex, type IndexerObject, ObjectMetaIndex, ReverseRefIndex } from './indexes';
 
@@ -20,11 +22,13 @@ const TYPE_DEFAULT = DXN.parse('dxn:type:test.com/type/Type:0.1.0').toString();
 const TYPE_A = DXN.parse('dxn:type:test.com/type/TypeA:0.1.0').toString();
 const TYPE_B = DXN.parse('dxn:type:test.com/type/TypeB:0.1.0').toString();
 
-const TestLayer = Layer.merge(
-  SqliteClient.layer({
-    filename: ':memory:',
-  }),
-  Reactivity.layer,
+const TestLayer = SqlTransaction.layer.pipe(
+  Layer.provideMerge(
+    SqliteClient.layer({
+      filename: ':memory:',
+    }),
+  ),
+  Layer.provideMerge(Reactivity.layer),
 );
 
 class MockIndexDataSource implements IndexDataSource {
@@ -46,6 +50,7 @@ class MockIndexDataSource implements IndexDataSource {
   }
 
   getChangedObjects(
+    _ctx: Context,
     cursors: IndexCursor[],
     opts?: { limit?: number },
   ): Effect.Effect<{ objects: IndexerObject[]; cursors: DataSourceCursor[] }> {
@@ -114,7 +119,9 @@ describe('IndexEngine', () => {
         spaceId,
         documentId: 'doc-1',
         queueId: null,
+        queueNamespace: null,
         recordId: null,
+        updatedAt: Date.now(),
         data: {
           id: ObjectId.random(),
           [ATTR_TYPE]: TYPE_DEFAULT,
@@ -125,7 +132,7 @@ describe('IndexEngine', () => {
       dataSource.push([obj1]);
 
       // First update.
-      const { updated } = yield* engine.update(dataSource, { spaceId: null });
+      const { updated } = yield* engine.update(Context.default(), dataSource, { spaceId: null });
       // Updates objectMeta, FTS, and reverseRef indexes.
       expect(updated).toBe(2);
 
@@ -150,13 +157,15 @@ describe('IndexEngine', () => {
         spaceId,
         documentId: obj1.documentId,
         queueId: null,
+        queueNamespace: null,
         recordId: null,
+        updatedAt: Date.now(),
         data: { id: obj1.data.id, [ATTR_TYPE]: obj1.data[ATTR_TYPE], title: 'Hello World' },
       };
       dataSource.push([obj1Updated]);
 
       // Second update.
-      const { updated: updated2 } = yield* engine.update(dataSource, { spaceId: null });
+      const { updated: updated2 } = yield* engine.update(Context.default(), dataSource, { spaceId: null });
       expect(updated2).toBe(2);
 
       // Verify update.
@@ -188,8 +197,10 @@ describe('IndexEngine', () => {
         {
           spaceId,
           queueId: null,
+          queueNamespace: null,
           documentId: 'd1',
           recordId: null,
+          updatedAt: Date.now(),
           data: {
             id: ObjectId.random(),
             [ATTR_TYPE]: TYPE_A,
@@ -199,8 +210,10 @@ describe('IndexEngine', () => {
         {
           spaceId,
           queueId: null,
+          queueNamespace: null,
           documentId: 'd2',
           recordId: null,
+          updatedAt: Date.now(),
           data: {
             id: ObjectId.random(),
             [ATTR_TYPE]: TYPE_A,
@@ -210,8 +223,10 @@ describe('IndexEngine', () => {
         {
           spaceId,
           queueId: null,
+          queueNamespace: null,
           documentId: 'd3',
           recordId: null,
+          updatedAt: Date.now(),
           data: {
             id: ObjectId.random(),
             [ATTR_TYPE]: TYPE_B,
@@ -222,7 +237,7 @@ describe('IndexEngine', () => {
 
       dataSource.push(objects);
 
-      yield* engine.update(dataSource, { spaceId: null });
+      yield* engine.update(Context.default(), dataSource, { spaceId: null });
 
       const resultsA = yield* metaIndex.query({ spaceId: spaceId.toString(), typeDxn: TYPE_A });
       expect(resultsA).toHaveLength(2);
@@ -239,4 +254,152 @@ describe('IndexEngine', () => {
       expect(ftsResults).toHaveLength(2);
     }, Effect.provide(TestLayer)),
   );
+
+  it.effect(
+    'done is true only when all sub-indexes have no remaining work',
+    Effect.fnUntraced(function* () {
+      const { tracker, metaIndex, ftsIndex, reverseRefIndex } = yield* setup;
+
+      const engine = new IndexEngine({ tracker, objectMetaIndex: metaIndex, ftsIndex, reverseRefIndex });
+      const dataSource = new MockIndexDataSource();
+      const spaceId = SpaceId.random();
+
+      // First update with no data — both sub-indexes report done immediately.
+      const { updated: updated0, done: done0 } = yield* engine.update(Context.default(), dataSource, { spaceId: null });
+      expect(updated0).toBe(0);
+      expect(done0).toBe(true);
+
+      // Push an object so sub-indexes have work to do.
+      dataSource.push([
+        {
+          spaceId,
+          queueId: null,
+          queueNamespace: null,
+          documentId: 'doc-done-test',
+          recordId: null,
+          updatedAt: Date.now(),
+          data: { id: ObjectId.random(), [ATTR_TYPE]: TYPE_DEFAULT, title: 'Done test' },
+        },
+      ]);
+
+      // Update with pending data — sub-indexes process objects, done is false.
+      const { updated: updated1, done: done1 } = yield* engine.update(Context.default(), dataSource, { spaceId: null });
+      expect(updated1).toBeGreaterThan(0);
+      expect(done1).toBe(false);
+
+      // Second update with no new data — all sub-indexes caught up, done is true.
+      const { updated: updated2, done: done2 } = yield* engine.update(Context.default(), dataSource, {
+        spaceId: null,
+      });
+      expect(updated2).toBe(0);
+      expect(done2).toBe(true);
+    }, Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    'IndexingResult contains correct sets for a batch with multiple objects across spaces',
+    Effect.fnUntraced(function* () {
+      const { tracker, metaIndex, ftsIndex, reverseRefIndex } = yield* setup;
+      const engine = new IndexEngine({ tracker, objectMetaIndex: metaIndex, ftsIndex, reverseRefIndex });
+      const dataSource = new MockIndexDataSource();
+      const spaceId1 = SpaceId.random();
+      const spaceId2 = SpaceId.random();
+      const id1 = ObjectId.random();
+      const id2 = ObjectId.random();
+
+      const obj1: IndexerObject = {
+        spaceId: spaceId1,
+        documentId: 'doc-result-1',
+        queueId: null,
+        queueNamespace: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: { id: id1, [ATTR_TYPE]: TYPE_A, title: 'Doc in space1' },
+      };
+      const obj2: IndexerObject = {
+        spaceId: spaceId2,
+        documentId: 'doc-result-2',
+        queueId: null,
+        queueNamespace: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: { id: id2, [ATTR_TYPE]: TYPE_B, title: 'Doc in space2' },
+      };
+
+      dataSource.push([obj1, obj2]);
+
+      const result: IndexingResult = yield* engine.update(Context.default(), dataSource, { spaceId: null });
+
+      expect(result.updated).toBeGreaterThan(0);
+      expect(result.done).toBe(false);
+
+      // Spaces: both spaceIds should be present.
+      expect(result.spaces.has(spaceId1)).toBe(true);
+      expect(result.spaces.has(spaceId2)).toBe(true);
+
+      // Documents: both doc IDs should be present.
+      expect(result.documents.has('doc-result-1')).toBe(true);
+      expect(result.documents.has('doc-result-2')).toBe(true);
+
+      // Types: both TYPE_A and TYPE_B.
+      expect(result.types.has(TYPE_A)).toBe(true);
+      expect(result.types.has(TYPE_B)).toBe(true);
+
+      // Object ids.
+      expect(result.objects.has(id1)).toBe(true);
+      expect(result.objects.has(id2)).toBe(true);
+    }, Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    'IndexingResult includes typename for deleted objects',
+    Effect.fnUntraced(function* () {
+      const { tracker, metaIndex, ftsIndex, reverseRefIndex } = yield* setup;
+      const engine = new IndexEngine({ tracker, objectMetaIndex: metaIndex, ftsIndex, reverseRefIndex });
+      const dataSource = new MockIndexDataSource();
+      const spaceId = SpaceId.random();
+
+      const deletedObj: IndexerObject = {
+        spaceId,
+        documentId: 'doc-deleted',
+        queueId: null,
+        queueNamespace: null,
+        recordId: null,
+        updatedAt: Date.now(),
+        data: {
+          id: ObjectId.random(),
+          [ATTR_TYPE]: TYPE_DEFAULT,
+          '@deleted': true,
+        },
+      };
+
+      dataSource.push([deletedObj]);
+
+      const result: IndexingResult = yield* engine.update(Context.default(), dataSource, { spaceId: null });
+
+      expect(result.updated).toBeGreaterThan(0);
+      // Deleted objects should still contribute their typename to the hint.
+      expect(result.types.has(TYPE_DEFAULT)).toBe(true);
+      expect(result.spaces.has(spaceId)).toBe(true);
+    }, Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    'IndexingResult is empty when no objects are indexed',
+    Effect.fnUntraced(function* () {
+      const { tracker, metaIndex, ftsIndex, reverseRefIndex } = yield* setup;
+      const engine = new IndexEngine({ tracker, objectMetaIndex: metaIndex, ftsIndex, reverseRefIndex });
+      const dataSource = new MockIndexDataSource();
+
+      const result: IndexingResult = yield* engine.update(Context.default(), dataSource, { spaceId: null });
+
+      expect(result.updated).toBe(0);
+      expect(result.done).toBe(true);
+      expect(result.spaces.size).toBe(0);
+      expect(result.queues.size).toBe(0);
+      expect(result.documents.size).toBe(0);
+      expect(result.types.size).toBe(0);
+      expect(result.objects.size).toBe(0);
+    }, Effect.provide(TestLayer)),
+  );
 });

package/src/index-engine.ts

@@ -2,16 +2,20 @@
 // Copyright 2026 DXOS.org
 //
 
-import * as SqlClient from '@effect/sql/SqlClient';
+import type * as SqlClient from '@effect/sql/SqlClient';
 import type * as SqlError from '@effect/sql/SqlError';
 import * as Effect from 'effect/Effect';
 
-import type { SpaceId } from '@dxos/keys';
+import { type Context } from '@dxos/context';
+import { ATTR_TYPE } from '@dxos/echo/internal';
+import type { ObjectId, SpaceId } from '@dxos/keys';
+import * as SqlTransaction from '@dxos/sql-sqlite/SqlTransaction';
 
 import { type IndexCursor, IndexTracker } from './index-tracker';
 import {
   FtsIndex,
   type FtsQuery,
+  type FtsQueryResult,
   type Index,
   type IndexerObject,
   type ObjectMeta,
@@ -20,6 +24,59 @@ import {
   type ReverseRefQuery,
 } from './indexes';
 
+/**
+ * Result of a single indexing pass over a data source.
+ * Carries enough metadata for callers to build targeted invalidation hints.
+ */
+export type IndexingResult = {
+  updated: number;
+  done: boolean;
+  spaces: ReadonlySet<SpaceId>;
+  queues: ReadonlySet<ObjectId>;
+  documents: ReadonlySet<string>;
+  types: ReadonlySet<string>;
+  objects: ReadonlySet<ObjectId>;
+};
+
+type MutableIndexingResult = {
+  updated: number;
+  done: boolean;
+  spaces: Set<SpaceId>;
+  queues: Set<ObjectId>;
+  documents: Set<string>;
+  types: Set<string>;
+  objects: Set<ObjectId>;
+};
+
+const makeEmptyIndexingResult = (): MutableIndexingResult => ({
+  updated: 0,
+  done: true,
+  spaces: new Set(),
+  queues: new Set(),
+  documents: new Set(),
+  types: new Set(),
+  objects: new Set(),
+});
+
+const accumulateIndexingResult = (acc: MutableIndexingResult, objects: readonly IndexerObject[]) => {
+  for (const obj of objects) {
+    acc.spaces.add(obj.spaceId);
+    if (obj.queueId) {
+      acc.queues.add(obj.queueId);
+    }
+    if (obj.documentId) {
+      acc.documents.add(obj.documentId);
+    }
+    const t = (obj.data as Record<string, unknown>)[ATTR_TYPE];
+    if (t) {
+      acc.types.add(String(t));
+    }
+    if (obj.data.id) {
+      acc.objects.add(obj.data.id as ObjectId);
+    }
+  }
+};
+
 /**
  * Cursor into indexable data-source.
  */
@@ -27,7 +84,7 @@ export interface DataSourceCursor {
   spaceId: SpaceId | null;
 
   /**
-   * documentId or queueId.
+   * documentId or queueNamespace.
    */
   resourceId: string | null;
 
@@ -41,6 +98,7 @@ export interface IndexDataSource {
   readonly sourceName: string; // e.g. queue, automerge, etc.
 
   getChangedObjects(
+    ctx: Context,
     cursors: DataSourceCursor[],
     opts?: { limit?: number },
   ): Effect.Effect<{ objects: IndexerObject[]; cursors: DataSourceCursor[] }>;
@@ -76,9 +134,9 @@ export class IndexEngine {
   }
 
   /**
-   * Query text index and return full object metadata.
+   * Query text index and return full object metadata with rank.
    */
-  queryText(query: FtsQuery): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+  queryText(query: FtsQuery): Effect.Effect<readonly FtsQueryResult[], SqlError.SqlError, SqlClient.SqlClient> {
     return Effect.gen(this, function* () {
       return yield* this.#ftsIndex.query(query);
     });
@@ -89,6 +147,14 @@ export class IndexEngine {
     return this.#reverseRefIndex.query(query);
   }
 
+  queryAll(query: {
+    spaceIds: readonly SpaceId[];
+    includeAllQueues?: boolean;
+    queueIds?: readonly string[] | null;
+  }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.queryAll(query);
+  }
+
   /**
    * Query snapshots by recordIds.
    * Used to load queue objects from indexed snapshots.
@@ -103,32 +169,90 @@ export class IndexEngine {
     return this.#objectMetaIndex.query(query);
   }
 
+  /**
+   * Query children by parent object ids.
+   */
+  queryChildren(query: {
+    spaceId: SpaceId[];
+    parentIds: ObjectId[];
+  }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.queryChildren(query);
+  }
+
+  queryTypes(query: {
+    spaceIds: readonly SpaceId[];
+    typeDxns: readonly ObjectMeta['typeDxn'][];
+    inverted?: boolean;
+    includeAllQueues?: boolean;
+    queueIds?: readonly string[] | null;
+  }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.queryTypes(query);
+  }
+  queryByTimeRange(query: {
+    spaceIds: readonly string[];
+    updatedAfter?: number;
+    updatedBefore?: number;
+    createdAfter?: number;
+    createdBefore?: number;
+    includeAllQueues?: boolean;
+    queueIds?: readonly string[] | null;
+  }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.queryByTimeRange(query);
+  }
+
+  queryRelations(query: {
+    endpoint: 'source' | 'target';
+    anchorDxns: readonly string[];
+  }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.queryRelations(query);
+  }
+  lookupByRecordIds(recordIds: number[]): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.lookupByRecordIds(recordIds);
+  }
+
+  lookupByObjectId(query: {
+    objectId: string;
+    spaceId: string;
+    queueId: string;
+  }): Effect.Effect<ObjectMeta | null, SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.lookupByObjectId(query);
+  }
+
   update(
+    ctx: Context,
     dataSource: IndexDataSource,
     opts: { spaceId: SpaceId | null; limit?: number },
-  ): Effect.Effect<{ updated: number; done: boolean }, SqlError.SqlError, SqlClient.SqlClient> {
+  ): Effect.Effect<IndexingResult, SqlError.SqlError, SqlTransaction.SqlTransaction | SqlClient.SqlClient> {
     return Effect.gen(this, function* () {
-      let updated = 0;
+      const result = makeEmptyIndexingResult();
 
-      const { updated: updatedFtsIndex, done: doneFtsIndex } = yield* this.#update(this.#ftsIndex, dataSource, {
-        indexName: 'fts',
+      const {
+        updated: updatedFtsIndex,
+        done: doneFtsIndex,
+        objects: ftsObjects,
+      } = yield* this.#update(ctx, this.#ftsIndex, dataSource, {
+        indexName: 'fts5',
         spaceId: opts.spaceId,
         limit: opts.limit,
       });
-      updated += updatedFtsIndex;
-
-      const { updated: updatedReverseRefIndex, done: doneReverseRefIndex } = yield* this.#update(
-        this.#reverseRefIndex,
-        dataSource,
-        {
-          indexName: 'reverseRef',
-          spaceId: opts.spaceId,
-          limit: opts.limit,
-        },
-      );
-      updated += updatedReverseRefIndex;
+      result.updated += updatedFtsIndex;
+      result.done = result.done && doneFtsIndex;
+      accumulateIndexingResult(result, ftsObjects);
 
-      return { updated, done: doneFtsIndex && doneReverseRefIndex };
+      const {
+        updated: updatedReverseRefIndex,
+        done: doneReverseRefIndex,
+        objects: reverseRefObjects,
+      } = yield* this.#update(ctx, this.#reverseRefIndex, dataSource, {
+        indexName: 'reverseRef',
+        spaceId: opts.spaceId,
+        limit: opts.limit,
+      });
+      result.updated += updatedReverseRefIndex;
+      result.done = result.done && doneReverseRefIndex;
+      accumulateIndexingResult(result, reverseRefObjects);
+
+      return result as IndexingResult;
     }).pipe(Effect.withSpan('IndexEngine.update'));
   }
 
@@ -142,13 +266,19 @@ export class IndexEngine {
    * 5. Updates the dependent index.
    */
   #update(
+    ctx: Context,
     index: Index,
     source: IndexDataSource,
     opts: { indexName: string; spaceId: SpaceId | null; limit?: number },
-  ): Effect.Effect<{ updated: number; done: boolean }, SqlError.SqlError, SqlClient.SqlClient> {
+  ): Effect.Effect<
+    { updated: number; done: boolean; objects: readonly IndexerObject[] },
+    SqlError.SqlError,
+    SqlTransaction.SqlTransaction | SqlClient.SqlClient
+  > {
     return Effect.gen(this, function* () {
-      const sql = yield* SqlClient.SqlClient;
-      return yield* sql.withTransaction(
+      const sqlTransaction = yield* SqlTransaction.SqlTransaction;
+
+      return yield* sqlTransaction.withTransaction(
         Effect.gen(this, function* () {
           const cursors = yield* this.#tracker.queryCursors({
             indexName: opts.indexName,
@@ -156,9 +286,11 @@ export class IndexEngine {
             // Pass undefined to get all cursors when spaceId is null.
             spaceId: opts.spaceId ?? undefined,
           });
-          const { objects, cursors: updatedCursors } = yield* source.getChangedObjects(cursors, { limit: opts.limit });
+          const { objects, cursors: updatedCursors } = yield* source.getChangedObjects(ctx, cursors, {
+            limit: opts.limit,
+          });
           if (objects.length === 0) {
-            return { updated: 0, done: true };
+            return { updated: 0, done: true, objects: [] as readonly IndexerObject[] };
           }
 
           // Ensure objects exist in ObjectMetaIndex.
@@ -179,9 +311,9 @@ export class IndexEngine {
               }),
             ),
           );
-          return { updated: objects.length, done: false };
+          return { updated: objects.length, done: false, objects };
         }),
       );
-    }).pipe(Effect.withSpan('IndexEngine.#updateDependentIndex'));
+    }).pipe(Effect.withSpan('IndexEngine.#update'));
   }
 }

package/src/index-tracker.ts

@@ -35,6 +35,11 @@ export const IndexCursor = Schema.Struct({
 });
 export interface IndexCursor extends Schema.Schema.Type<typeof IndexCursor> {}
 
+/**
+ * Deprecated index names that are no longer used. Will be cleaned up on migration.
+ */
+const DEPRECATED_INDEX_NAMES = ['fts'];
+
 export class IndexTracker {
   migrate = Effect.fn('IndexTracker.migrate')(function* () {
     const sql = yield* SqlClient.SqlClient;
@@ -49,6 +54,10 @@ export class IndexTracker {
       cursor,
       PRIMARY KEY (indexName, spaceId, sourceName, resourceId)
     )`;
+
+    yield* Effect.forEach(DEPRECATED_INDEX_NAMES, (indexName) => {
+      return sql`DELETE FROM indexCursor WHERE indexName = ${indexName}`;
+    });
   });
 
   queryCursors = Effect.fn('IndexTracker.queryCursors')(

package/src/index.ts

@@ -2,9 +2,16 @@
 // Copyright 2025 DXOS.org
 //
 
-export { IndexEngine, type IndexDataSource, type DataSourceCursor, type IndexEngineParams } from './index-engine';
+export {
+  IndexEngine,
+  type IndexDataSource,
+  type DataSourceCursor,
+  type IndexEngineParams,
+  type IndexingResult,
+} from './index-engine';
 export { IndexTracker, type IndexCursor } from './index-tracker';
 export { type IndexerObject, type Index } from './indexes/interface';
-export { FtsIndex } from './indexes/fts-index';
+export { FtsIndex, type FtsQuery } from './indexes/fts-index';
 export { ObjectMetaIndex, type ObjectMeta } from './indexes/object-meta-index';
-export { ReverseRefIndex, type ReverseRef } from './indexes/reverse-ref-index';
+export { ReverseRefIndex, type ReverseRef, type ReverseRefQuery } from './indexes/reverse-ref-index';
+export { EscapedPropPath, type ObjectPropPath } from './utils';