@dxos/index-core 0.0.0

package/LICENSE

@@ -0,0 +1,8 @@
+MIT License 
+Copyright (c) 2022 DXOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# @dxos/index-core
+
+Indexing core.
+
+## Installation
+
+```bash
+pnpm i @dxos/index-core
+```
+
+## DXOS Resources
+
+- [Website](https://dxos.org)
+- [Developer Documentation](https://docs.dxos.org)
+- Talk to us on [Discord](https://dxos.org/discord)
+
+## Contributions
+
+Your ideas, issues, and code are most welcome. Please take a look at our [community code of conduct](https://github.com/dxos/dxos/blob/main/CODE_OF_CONDUCT.md), the [issue guide](https://github.com/dxos/dxos/blob/main/CONTRIBUTING.md#submitting-issues), and the [PR contribution guide](https://github.com/dxos/dxos/blob/main/CONTRIBUTING.md#submitting-prs).
+
+License: [MIT](./LICENSE) Copyright 2022 © DXOS

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@dxos/index-core",
+  "version": "0.0.0",
+  "description": "Indexing core.",
+  "homepage": "https://dxos.org",
+  "bugs": "https://github.com/dxos/dxos/issues",
+  "license": "MIT",
+  "author": "info@dxos.org",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/types/src/index.d.ts",
+      "browser": "./dist/lib/browser/index.mjs",
+      "node": "./dist/lib/node-esm/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "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"
+  },
+  "devDependencies": {
+    "@effect/sql-sqlite-node": "0.49.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "beast": {}
+}

package/src/index-engine.test.ts

@@ -0,0 +1,242 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Reactivity from '@effect/experimental/Reactivity';
+import * as SqliteClient from '@effect/sql-sqlite-node/SqliteClient';
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { ATTR_TYPE } from '@dxos/echo/internal';
+import { invariant } from '@dxos/invariant';
+import { DXN, ObjectId, SpaceId } from '@dxos/keys';
+
+import { type DataSourceCursor, type IndexDataSource, IndexEngine } from './index-engine';
+import { type IndexCursor, IndexTracker } from './index-tracker';
+import { FtsIndex, type IndexerObject, ObjectMetaIndex, ReverseRefIndex } from './indexes';
+
+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,
+);
+
+class MockIndexDataSource implements IndexDataSource {
+  readonly sourceName = 'mock-source';
+
+  // Composite Key -> { object, hash, timestamp }
+  // Key: `${spaceId}:${documentId}`
+  private _state = new Map<string, { object: IndexerObject; hash: string }>();
+
+  push(objects: IndexerObject[]) {
+    for (const obj of objects) {
+      invariant(obj.documentId, 'documentId is required');
+
+      this._state.set(`${obj.spaceId}:${obj.documentId}`, {
+        object: obj,
+        hash: Math.random().toString(36).substring(7),
+      });
+    }
+  }
+
+  getChangedObjects(
+    cursors: IndexCursor[],
+    opts?: { limit?: number },
+  ): Effect.Effect<{ objects: IndexerObject[]; cursors: DataSourceCursor[] }> {
+    return Effect.sync(() => {
+      const results: { object: IndexerObject; hash: string }[] = [];
+
+      for (const [, entry] of this._state.entries()) {
+        const { object, hash } = entry;
+
+        // Find cursor for this object.
+        // Multi-space indexing: match by resourceId (documentId) only.
+        const cursor = cursors.find((c) => c.resourceId === object.documentId);
+
+        let include = false;
+        if (!cursor) {
+          include = true;
+        } else {
+          include = cursor.cursor !== hash;
+        }
+
+        if (include) {
+          results.push({ object, hash });
+        }
+      }
+
+      // Apply limit if needed (simplistic logic).
+      const limitedResults = opts?.limit ? results.slice(0, opts.limit) : results;
+
+      const objects = limitedResults.map((r) => r.object);
+      const newCursors: DataSourceCursor[] = limitedResults.map((r) => ({
+        spaceId: r.object.spaceId,
+        resourceId: r.object.documentId,
+        cursor: r.hash,
+      }));
+
+      return { objects, cursors: newCursors };
+    });
+  }
+}
+
+describe('IndexEngine', () => {
+  const setup = Effect.gen(function* () {
+    const tracker = new IndexTracker();
+    yield* tracker.migrate();
+    const metaIndex = new ObjectMetaIndex();
+    yield* metaIndex.migrate();
+    const ftsIndex = new FtsIndex();
+    yield* ftsIndex.migrate();
+    const reverseRefIndex = new ReverseRefIndex();
+    yield* reverseRefIndex.migrate();
+    const indexEngine = new IndexEngine({ tracker, ftsIndex, objectMetaIndex: metaIndex, reverseRefIndex });
+    return { indexEngine, tracker, metaIndex, ftsIndex, reverseRefIndex };
+  });
+
+  it.effect(
+    'should index and update objects',
+    Effect.fnUntraced(function* () {
+      const { tracker, metaIndex, ftsIndex, reverseRefIndex } = yield* setup;
+
+      // Inject dependencies.
+      const engine = new IndexEngine({ tracker, ftsIndex, objectMetaIndex: metaIndex, reverseRefIndex });
+      const dataSource = new MockIndexDataSource();
+      const spaceId = SpaceId.random();
+
+      const obj1: IndexerObject = {
+        spaceId,
+        documentId: 'doc-1',
+        queueId: null,
+        recordId: null,
+        data: {
+          id: ObjectId.random(),
+          [ATTR_TYPE]: TYPE_DEFAULT,
+          title: 'Hello',
+        },
+      };
+
+      dataSource.push([obj1]);
+
+      // First update.
+      const { updated } = yield* engine.update(dataSource, { spaceId: null });
+      // Updates objectMeta, FTS, and reverseRef indexes.
+      expect(updated).toBe(2);
+
+      // Verify using the SAME index instance.
+      const results1 = yield* metaIndex.query({ spaceId: spaceId.toString(), typeDxn: TYPE_DEFAULT });
+      expect(results1).toHaveLength(1);
+      expect(results1[0].objectId).toBe(obj1.data.id);
+      expect(results1[0].version).toBeGreaterThan(0);
+
+      // Verify FTS index gets updated.
+      const ftsResults1 = yield* ftsIndex.query({
+        query: 'Hello',
+        spaceId: null,
+        includeAllQueues: false,
+        queueIds: null,
+      });
+      expect(ftsResults1.length).toBeGreaterThan(0);
+      expect(ftsResults1.some((row) => row.objectId === obj1.data.id)).toBe(true);
+
+      // Update object.
+      const obj1Updated: IndexerObject = {
+        spaceId,
+        documentId: obj1.documentId,
+        queueId: null,
+        recordId: null,
+        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 });
+      expect(updated2).toBe(2);
+
+      // Verify update.
+      const results2 = yield* metaIndex.query({ spaceId: spaceId.toString(), typeDxn: TYPE_DEFAULT });
+      expect(results2).toHaveLength(1);
+      expect(results2[0].objectId).toBe(obj1Updated.data.id);
+      expect(results2[0].version).toBeGreaterThan(results1[0].version);
+
+      const ftsResults2 = yield* ftsIndex.query({
+        query: 'World',
+        spaceId: null,
+        includeAllQueues: false,
+        queueIds: null,
+      });
+      expect(ftsResults2.length).toBeGreaterThan(0);
+    }, Effect.provide(TestLayer)),
+  );
+
+  it.effect(
+    'should handle multiple 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 objects: IndexerObject[] = [
+        {
+          spaceId,
+          queueId: null,
+          documentId: 'd1',
+          recordId: null,
+          data: {
+            id: ObjectId.random(),
+            [ATTR_TYPE]: TYPE_A,
+            val: 1,
+          },
+        },
+        {
+          spaceId,
+          queueId: null,
+          documentId: 'd2',
+          recordId: null,
+          data: {
+            id: ObjectId.random(),
+            [ATTR_TYPE]: TYPE_A,
+            val: 2,
+          },
+        },
+        {
+          spaceId,
+          queueId: null,
+          documentId: 'd3',
+          recordId: null,
+          data: {
+            id: ObjectId.random(),
+            [ATTR_TYPE]: TYPE_B,
+            val: 3,
+          },
+        },
+      ];
+
+      dataSource.push(objects);
+
+      yield* engine.update(dataSource, { spaceId: null });
+
+      const resultsA = yield* metaIndex.query({ spaceId: spaceId.toString(), typeDxn: TYPE_A });
+      expect(resultsA).toHaveLength(2);
+
+      const resultsB = yield* metaIndex.query({ spaceId: spaceId.toString(), typeDxn: TYPE_B });
+      expect(resultsB).toHaveLength(1);
+
+      const ftsResults = yield* ftsIndex.query({
+        query: 'TypeA',
+        spaceId: null,
+        includeAllQueues: false,
+        queueIds: null,
+      });
+      expect(ftsResults).toHaveLength(2);
+    }, Effect.provide(TestLayer)),
+  );
+});

package/src/index-engine.ts

@@ -0,0 +1,187 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * 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 IndexCursor, IndexTracker } from './index-tracker';
+import {
+  FtsIndex,
+  type FtsQuery,
+  type Index,
+  type IndexerObject,
+  type ObjectMeta,
+  ObjectMetaIndex,
+  ReverseRefIndex,
+  type ReverseRefQuery,
+} from './indexes';
+
+/**
+ * Cursor into indexable data-source.
+ */
+export interface DataSourceCursor {
+  spaceId: SpaceId | null;
+
+  /**
+   * documentId or queueId.
+   */
+  resourceId: string | null;
+
+  /**
+   * heads or queue position.
+   */
+  cursor: number | string;
+}
+
+export interface IndexDataSource {
+  readonly sourceName: string; // e.g. queue, automerge, etc.
+
+  getChangedObjects(
+    cursors: DataSourceCursor[],
+    opts?: { limit?: number },
+  ): Effect.Effect<{ objects: IndexerObject[]; cursors: DataSourceCursor[] }>;
+}
+
+export interface IndexEngineParams {
+  tracker: IndexTracker;
+  objectMetaIndex: ObjectMetaIndex;
+  ftsIndex: FtsIndex;
+  reverseRefIndex: ReverseRefIndex;
+}
+
+export class IndexEngine {
+  readonly #tracker: IndexTracker;
+  readonly #objectMetaIndex: ObjectMetaIndex;
+  readonly #ftsIndex: FtsIndex;
+  readonly #reverseRefIndex: ReverseRefIndex;
+
+  constructor(params?: IndexEngineParams) {
+    this.#tracker = params?.tracker ?? new IndexTracker();
+    this.#objectMetaIndex = params?.objectMetaIndex ?? new ObjectMetaIndex();
+    this.#ftsIndex = params?.ftsIndex ?? new FtsIndex();
+    this.#reverseRefIndex = params?.reverseRefIndex ?? new ReverseRefIndex();
+  }
+
+  migrate() {
+    return Effect.gen(this, function* () {
+      yield* this.#tracker.migrate();
+      yield* this.#objectMetaIndex.migrate();
+      yield* this.#ftsIndex.migrate();
+      yield* this.#reverseRefIndex.migrate();
+    });
+  }
+
+  /**
+   * Query text index and return full object metadata.
+   */
+  queryText(query: FtsQuery): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return Effect.gen(this, function* () {
+      return yield* this.#ftsIndex.query(query);
+    });
+  }
+
+  queryReverseRef(query: ReverseRefQuery) {
+    // TODO(mykola): Join with metadata table here.
+    return this.#reverseRefIndex.query(query);
+  }
+
+  /**
+   * Query snapshots by recordIds.
+   * Used to load queue objects from indexed snapshots.
+   */
+  querySnapshotsJSON(recordIds: number[]) {
+    return this.#ftsIndex.querySnapshotsJSON(recordIds);
+  }
+
+  queryType(
+    query: Pick<ObjectMeta, 'spaceId' | 'typeDxn'>,
+  ): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> {
+    return this.#objectMetaIndex.query(query);
+  }
+
+  update(
+    dataSource: IndexDataSource,
+    opts: { spaceId: SpaceId | null; limit?: number },
+  ): Effect.Effect<{ updated: number; done: boolean }, SqlError.SqlError, SqlClient.SqlClient> {
+    return Effect.gen(this, function* () {
+      let updated = 0;
+
+      const { updated: updatedFtsIndex, done: doneFtsIndex } = yield* this.#update(this.#ftsIndex, dataSource, {
+        indexName: 'fts',
+        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;
+
+      return { updated, done: doneFtsIndex && doneReverseRefIndex };
+    }).pipe(Effect.withSpan('IndexEngine.update'));
+  }
+
+  /**
+   * Update a dependent index that requires recordId enrichment.
+   * This method:
+   * 1. Gets changed objects from the source.
+   * 2. Ensures those objects exist in ObjectMetaIndex.
+   * 3. Looks up recordIds for those objects.
+   * 4. Enriches objects with recordIds.
+   * 5. Updates the dependent index.
+   */
+  #update(
+    index: Index,
+    source: IndexDataSource,
+    opts: { indexName: string; spaceId: SpaceId | null; limit?: number },
+  ): Effect.Effect<{ updated: number; done: boolean }, SqlError.SqlError, SqlClient.SqlClient> {
+    return Effect.gen(this, function* () {
+      const sql = yield* SqlClient.SqlClient;
+      return yield* sql.withTransaction(
+        Effect.gen(this, function* () {
+          const cursors = yield* this.#tracker.queryCursors({
+            indexName: opts.indexName,
+            sourceName: source.sourceName,
+            // 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 });
+          if (objects.length === 0) {
+            return { updated: 0, done: true };
+          }
+
+          // Ensure objects exist in ObjectMetaIndex.
+          yield* this.#objectMetaIndex.update(objects);
+
+          // Look up recordIds for the objects.
+          yield* this.#objectMetaIndex.lookupRecordIds(objects);
+
+          yield* index.update(objects);
+          yield* this.#tracker.updateCursors(
+            updatedCursors.map(
+              (_): IndexCursor => ({
+                indexName: opts.indexName,
+                spaceId: _.spaceId,
+                sourceName: source.sourceName,
+                resourceId: _.resourceId,
+                cursor: _.cursor,
+              }),
+            ),
+          );
+          return { updated: objects.length, done: false };
+        }),
+      );
+    }).pipe(Effect.withSpan('IndexEngine.#updateDependentIndex'));
+  }
+}

package/src/index-tracker.test.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Reactivity from '@effect/experimental/Reactivity';
+import * as SqliteClient from '@effect/sql-sqlite-node/SqliteClient';
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { SpaceId } from '@dxos/keys';
+
+import { type IndexCursor, IndexTracker } from './index-tracker';
+
+const TestLayer = Layer.merge(
+  SqliteClient.layer({
+    filename: ':memory:',
+  }),
+  Reactivity.layer,
+);
+
+describe('IndexTracker', () => {
+  it.effect(
+    'should store and retrieve index cursors',
+    Effect.fnUntraced(function* () {
+      const tracker = new IndexTracker();
+      yield* tracker.migrate();
+
+      const cursor1: IndexCursor = {
+        indexName: 'test-index',
+        spaceId: SpaceId.random(),
+        sourceName: 'automerge',
+        resourceId: 'doc-1',
+        cursor: 'heads-1',
+      };
+
+      const cursor2: IndexCursor = {
+        indexName: 'test-index',
+        spaceId: null,
+        sourceName: 'queue',
+        resourceId: 'queue-1',
+        cursor: 123,
+      };
+
+      // Test Insert
+      yield* tracker.updateCursors([cursor1, cursor2]);
+
+      // Test Query All for index
+      const results = yield* tracker.queryCursors({ indexName: 'test-index' });
+      expect(results.length).toBe(2);
+      expect(results).toContainEqual(cursor1);
+      expect(results).toContainEqual(cursor2);
+
+      // Test Query with Filter
+      const filtered = yield* tracker.queryCursors({ indexName: 'test-index', sourceName: 'automerge' });
+      expect(filtered.length).toBe(1);
+      expect(filtered[0]).toEqual(cursor1);
+
+      // Test Update
+      const updatedCursor1 = { ...cursor1, cursor: 'heads-2' };
+      yield* tracker.updateCursors([updatedCursor1]);
+
+      const resultsAfterUpdate = yield* tracker.queryCursors({ indexName: 'test-index', resourceId: 'doc-1' });
+      expect(resultsAfterUpdate[0].cursor).toBe('heads-2');
+
+      // Test null handling (empty string in DB)
+      const resultsNullSpace = yield* tracker.queryCursors({ indexName: 'test-index', spaceId: null });
+      expect(resultsNullSpace.length).toBe(1);
+      expect(resultsNullSpace[0]).toEqual(cursor2);
+    }, Effect.provide(TestLayer)),
+  );
+});

package/src/index-tracker.ts

@@ -0,0 +1,104 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as SqlClient from '@effect/sql/SqlClient';
+import type * as SqlError from '@effect/sql/SqlError';
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { SpaceId } from '@dxos/keys';
+
+export const IndexCursor = Schema.Struct({
+  /**
+   * Name of the index owning this cursor.
+   */
+  indexName: Schema.String,
+  /**
+   * Space id.
+   */
+  spaceId: Schema.NullOr(SpaceId),
+  /**
+   * Source name.
+   * 'automerge' / 'queue' / 'index' (for secondary indexes)
+   */
+  sourceName: Schema.String,
+  /**
+   * Document id or queue id.
+   * doc_id, queue_id, '' <empty string> (if indexing entire namespace)
+   */
+  resourceId: Schema.NullOr(Schema.String),
+  /**
+   * Heads, queue position, version.
+   */
+  cursor: Schema.Union(Schema.Number, Schema.String),
+});
+export interface IndexCursor extends Schema.Schema.Type<typeof IndexCursor> {}
+
+export class IndexTracker {
+  migrate = Effect.fn('IndexTracker.migrate')(function* () {
+    const sql = yield* SqlClient.SqlClient;
+
+    // For automerge: last-indexed heads of the document
+    // For queue: the position of the item that was indexed last
+    yield* sql`CREATE TABLE IF NOT EXISTS indexCursor (
+      indexName TEXT NOT NULL,
+      spaceId TEXT NOT NULL DEFAULT '',
+      sourceName TEXT NOT NULL,
+      resourceId TEXT NOT NULL DEFAULT '',
+      cursor,
+      PRIMARY KEY (indexName, spaceId, sourceName, resourceId)
+    )`;
+  });
+
+  queryCursors = Effect.fn('IndexTracker.queryCursors')(
+    (
+      query: Pick<IndexCursor, 'indexName'> & Partial<Pick<IndexCursor, 'sourceName' | 'resourceId' | 'spaceId'>>,
+    ): Effect.Effect<IndexCursor[], SqlError.SqlError, SqlClient.SqlClient> =>
+      Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+
+        const spaceIdParam = query.spaceId === undefined ? null : (query.spaceId ?? '');
+        const sourceNameParam = query.sourceName === undefined ? null : query.sourceName;
+        const resourceIdParam = query.resourceId === undefined ? null : (query.resourceId ?? '');
+
+        const rows = yield* sql<IndexCursor>`
+            SELECT * FROM indexCursor 
+            WHERE indexName = ${query.indexName}
+            AND (${spaceIdParam} IS NULL OR spaceId = ${spaceIdParam})
+            AND (${sourceNameParam} IS NULL OR sourceName = ${sourceNameParam})
+            AND (${resourceIdParam} IS NULL OR resourceId = ${resourceIdParam})
+        `;
+
+        return rows.map(
+          (row): IndexCursor => ({
+            indexName: row.indexName,
+            spaceId: row.spaceId === '' ? null : Schema.decodeSync(SpaceId)(row.spaceId!),
+            sourceName: row.sourceName,
+            resourceId: row.resourceId === '' ? null : row.resourceId,
+            cursor: row.cursor,
+          }),
+        );
+      }),
+  );
+
+  updateCursors = Effect.fn('IndexTracker.updateCursors')(
+    (cursors: IndexCursor[]): Effect.Effect<void, SqlError.SqlError, SqlClient.SqlClient> =>
+      Effect.gen(function* () {
+        const sql = yield* SqlClient.SqlClient;
+        yield* Effect.forEach(
+          cursors,
+          (cursor) => {
+            const spaceId = cursor.spaceId ?? '';
+            const resourceId = cursor.resourceId ?? '';
+            return sql`
+            INSERT INTO indexCursor (indexName, spaceId, sourceName, resourceId, cursor)
+            VALUES (${cursor.indexName}, ${spaceId}, ${cursor.sourceName}, ${resourceId}, ${cursor.cursor})
+            ON CONFLICT(indexName, spaceId, sourceName, resourceId) DO UPDATE SET cursor = excluded.cursor
+          `;
+          },
+          { discard: true },
+        );
+      }),
+  );
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { IndexEngine, type IndexDataSource, type DataSourceCursor, type IndexEngineParams } 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 { ObjectMetaIndex, type ObjectMeta } from './indexes/object-meta-index';
+export { ReverseRefIndex, type ReverseRef } from './indexes/reverse-ref-index';