@dxos/index-core 0.0.0 → 0.8.4-main.52d7546f51

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,658 @@
+// src/index-engine.ts
+import * as Effect5 from "effect/Effect";
+import * as SqlTransaction from "@dxos/sql-sqlite/SqlTransaction";
+
+// src/index-tracker.ts
+import * as SqlClient from "@effect/sql/SqlClient";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { SpaceId } from "@dxos/keys";
+var 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)
+});
+var IndexTracker = class {
+  migrate = Effect.fn("IndexTracker.migrate")(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    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) => Effect.gen(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const spaceIdParam = query.spaceId === void 0 ? null : query.spaceId ?? "";
+    const sourceNameParam = query.sourceName === void 0 ? null : query.sourceName;
+    const resourceIdParam = query.resourceId === void 0 ? null : query.resourceId ?? "";
+    const rows = yield* sql`
+            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) => ({
+      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) => 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
+    });
+  }));
+};
+
+// src/indexes/fts-index.ts
+import * as SqlClient3 from "@effect/sql/SqlClient";
+import * as Effect2 from "effect/Effect";
+var escapeFts5Query = (text) => {
+  return text.split(/\s+/).filter(Boolean).map((term) => `"${term.replace(/"/g, '""')}"`).join(" ");
+};
+var FtsIndex = class {
+  migrate = Effect2.fn("FtsIndex.migrate")(function* () {
+    const sql = yield* SqlClient3.SqlClient;
+    yield* sql`CREATE VIRTUAL TABLE IF NOT EXISTS ftsIndex USING fts5(snapshot, tokenize='trigram')`;
+  });
+  query({ query, spaceId, includeAllQueues, queueIds }) {
+    return Effect2.gen(function* () {
+      const trimmed = query.trim();
+      if (trimmed.length === 0) {
+        return [];
+      }
+      const sql = yield* SqlClient3.SqlClient;
+      const terms = trimmed.split(/\s+/).filter(Boolean);
+      const minTermLength = Math.min(...terms.map((t) => t.length));
+      const useBm25 = minTermLength >= 3;
+      const conditions = minTermLength < 3 ? terms.map((term) => sql`f.snapshot LIKE ${"%" + term + "%"}`) : [
+        sql`f.snapshot MATCH ${escapeFts5Query(trimmed)}`
+      ];
+      const sourceConditions = [];
+      if (spaceId && spaceId.length > 0) {
+        if (includeAllQueues) {
+          sourceConditions.push(sql`m.spaceId IN ${sql.in(spaceId)}`);
+        } else {
+          sourceConditions.push(sql`(m.spaceId IN ${sql.in(spaceId)} AND m.queueId = '')`);
+        }
+      }
+      if (queueIds && queueIds.length > 0) {
+        sourceConditions.push(sql`m.queueId IN ${sql.in(queueIds)}`);
+      }
+      if (sourceConditions.length > 0) {
+        conditions.push(sql`(${sql.or(sourceConditions)})`);
+      }
+      if (useBm25) {
+        const rows = yield* sql`
+          SELECT m.*, -bm25(ftsIndex) AS rank 
+          FROM ftsIndex AS f 
+          JOIN objectMeta AS m ON f.rowid = m.recordId 
+          WHERE ${sql.and(conditions)}
+          ORDER BY rank DESC
+        `;
+        return rows;
+      } else {
+        const rows = yield* sql`
+          SELECT m.* 
+          FROM ftsIndex AS f 
+          JOIN objectMeta AS m ON f.rowid = m.recordId 
+          WHERE ${sql.and(conditions)}
+        `;
+        return rows.map((row) => ({
+          ...row,
+          rank: 1
+        }));
+      }
+    });
+  }
+  /**
+  * Query snapshots by recordIds.
+  * Returns the parsed JSON snapshots for queue objects.
+  */
+  querySnapshotsJSON(recordIds) {
+    return Effect2.gen(function* () {
+      if (recordIds.length === 0) {
+        return [];
+      }
+      const sql = yield* SqlClient3.SqlClient;
+      const results = yield* sql`SELECT rowid, snapshot FROM ftsIndex WHERE rowid IN ${sql.in(recordIds)}`;
+      return results.map((r) => ({
+        recordId: r.rowid,
+        snapshot: JSON.parse(r.snapshot)
+      }));
+    });
+  }
+  update = Effect2.fn("FtsIndex.update")((objects) => Effect2.gen(function* () {
+    const sql = yield* SqlClient3.SqlClient;
+    yield* Effect2.forEach(objects, (object) => Effect2.gen(function* () {
+      const { recordId, data } = object;
+      if (recordId === null) {
+        return yield* Effect2.die(new Error("FtsIndex.update requires recordId to be set"));
+      }
+      const snapshot = JSON.stringify(data);
+      const existing = yield* sql`SELECT rowid FROM ftsIndex WHERE rowid = ${recordId}`;
+      if (existing.length > 0) {
+        yield* sql`DELETE FROM ftsIndex WHERE rowid = ${recordId}`;
+      }
+      yield* sql`INSERT INTO ftsIndex (rowid, snapshot) VALUES (${recordId}, ${snapshot})`;
+    }), {
+      discard: true
+    });
+  }));
+};
+
+// src/indexes/object-meta-index.ts
+import * as SqlClient5 from "@effect/sql/SqlClient";
+import * as Effect3 from "effect/Effect";
+import * as Schema2 from "effect/Schema";
+import { ATTR_DELETED, ATTR_PARENT, ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET, ATTR_TYPE } from "@dxos/echo/internal";
+import { DXN } from "@dxos/keys";
+var _escapeLikePrefix = (prefix) => {
+  const escaped = prefix.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+  return `${escaped}:%`;
+};
+var ObjectMeta = Schema2.Struct({
+  recordId: Schema2.Number,
+  objectId: Schema2.String,
+  queueId: Schema2.String,
+  spaceId: Schema2.String,
+  documentId: Schema2.String,
+  entityKind: Schema2.String,
+  /** The versioned DXN of the type of the object. */
+  typeDxn: Schema2.String,
+  deleted: Schema2.Boolean,
+  source: Schema2.NullOr(Schema2.String),
+  target: Schema2.NullOr(Schema2.String),
+  /** Parent object id (nullable). */
+  parent: Schema2.NullOr(Schema2.String),
+  /** Monotonically increasing sequence number assigned on insert/update for tracking indexing order. */
+  version: Schema2.Number
+});
+var ObjectMetaIndex = class {
+  migrate = Effect3.fn("ObjectMetaIndex.runMigrations")(function* () {
+    const sql = yield* SqlClient5.SqlClient;
+    yield* sql`CREATE TABLE IF NOT EXISTS objectMeta (
+      recordId INTEGER PRIMARY KEY AUTOINCREMENT,
+      objectId TEXT NOT NULL,
+      queueId TEXT NOT NULL DEFAULT '',
+      spaceId TEXT NOT NULL,
+      documentId TEXT NOT NULL DEFAULT '',
+      entityKind TEXT NOT NULL,
+      typeDxn TEXT NOT NULL,
+      deleted INTEGER NOT NULL,
+      source TEXT,
+      target TEXT,
+      parent TEXT,
+      version INTEGER NOT NULL
+    )`;
+    yield* Effect3.catchAll(sql`ALTER TABLE objectMeta ADD COLUMN parent TEXT`, () => Effect3.void);
+    yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_objectId ON objectMeta(spaceId, objectId)`;
+    yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_typeDxn ON objectMeta(spaceId, typeDxn)`;
+    yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_version ON objectMeta(version)`;
+    yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_parent ON objectMeta(spaceId, parent)`;
+  });
+  query = Effect3.fn("ObjectMetaIndex.query")((query) => Effect3.gen(function* () {
+    const sql = yield* SqlClient5.SqlClient;
+    const parsedType = DXN.tryParse(query.typeDxn)?.asTypeDXN();
+    const rows = parsedType && parsedType.version === void 0 ? yield* sql`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND (typeDxn = ${query.typeDxn} OR typeDxn LIKE ${_escapeLikePrefix(query.typeDxn)} ESCAPE '\\')` : yield* sql`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND typeDxn = ${query.typeDxn}`;
+    return rows.map((row) => ({
+      ...row,
+      deleted: !!row.deleted
+    }));
+  }));
+  queryAll = Effect3.fn("ObjectMetaIndex.queryAll")((query) => Effect3.gen(function* () {
+    if (query.spaceIds.length === 0) {
+      return [];
+    }
+    const sql = yield* SqlClient5.SqlClient;
+    const rows = yield* sql`SELECT * FROM objectMeta WHERE ${sql.in("spaceId", query.spaceIds)}`;
+    return rows.map((row) => ({
+      ...row,
+      deleted: !!row.deleted
+    }));
+  }));
+  queryTypes = Effect3.fn("ObjectMetaIndex.queryTypes")(({ spaceIds, typeDxns, inverted = false }) => Effect3.gen(function* () {
+    if (spaceIds.length === 0) {
+      return [];
+    }
+    if (typeDxns.length === 0) {
+      if (!inverted) {
+        return [];
+      }
+      const sql2 = yield* SqlClient5.SqlClient;
+      const rows2 = yield* sql2`SELECT * FROM objectMeta WHERE ${sql2.in("spaceId", spaceIds)}`;
+      return rows2.map((row) => ({
+        ...row,
+        deleted: !!row.deleted
+      }));
+    }
+    const sql = yield* SqlClient5.SqlClient;
+    const spaceWhere = sql.in("spaceId", spaceIds);
+    const typeWhere = sql.or(typeDxns.map((typeDxn) => {
+      const parsedType = DXN.tryParse(typeDxn)?.asTypeDXN();
+      return parsedType && parsedType.version === void 0 ? sql.or([
+        sql`typeDxn = ${typeDxn}`,
+        sql`typeDxn LIKE ${_escapeLikePrefix(typeDxn)} ESCAPE '\\'`
+      ]) : sql`typeDxn = ${typeDxn}`;
+    }));
+    const rows = inverted ? yield* sql`SELECT * FROM objectMeta WHERE ${spaceWhere} AND NOT ${typeWhere}` : yield* sql`SELECT * FROM objectMeta WHERE ${spaceWhere} AND ${typeWhere}`;
+    return rows.map((row) => ({
+      ...row,
+      deleted: !!row.deleted
+    }));
+  }));
+  queryRelations = Effect3.fn("ObjectMetaIndex.queryRelations")(({ endpoint, anchorDxns }) => Effect3.gen(function* () {
+    if (anchorDxns.length === 0) {
+      return [];
+    }
+    const sql = yield* SqlClient5.SqlClient;
+    const column = endpoint === "source" ? "source" : "target";
+    const rows = yield* sql`SELECT * FROM objectMeta WHERE entityKind = 'relation' AND ${sql.in(column, anchorDxns)}`;
+    return rows.map((row) => ({
+      ...row,
+      deleted: !!row.deleted
+    }));
+  }));
+  // TODO(dmaretskyi): Update recordId on objects so that we don't need to look it up separately.
+  update = Effect3.fn("ObjectMetaIndex.update")((objects) => Effect3.gen(function* () {
+    const sql = yield* SqlClient5.SqlClient;
+    yield* Effect3.forEach(objects, (object) => Effect3.gen(function* () {
+      const { spaceId, queueId, documentId, data } = object;
+      const castData = data;
+      const objectId = castData.id;
+      let existing;
+      if (documentId) {
+        existing = yield* sql`SELECT recordId FROM objectMeta WHERE spaceId = ${spaceId} AND documentId = ${documentId} AND objectId = ${objectId} LIMIT 1`;
+      } else if (queueId) {
+        existing = yield* sql`SELECT recordId FROM objectMeta WHERE spaceId = ${spaceId} AND queueId = ${queueId} AND objectId = ${objectId} LIMIT 1`;
+      } else {
+        existing = [];
+      }
+      const result = yield* sql`SELECT MAX(version) as v FROM objectMeta`;
+      const [{ v }] = result;
+      const version = (v ?? 0) + 1;
+      const entityKind = castData[ATTR_RELATION_SOURCE] ? "relation" : "object";
+      const typeDxn = castData[ATTR_TYPE] ? String(castData[ATTR_TYPE]) : "type";
+      const deleted = castData[ATTR_DELETED] ? 1 : 0;
+      const source = entityKind === "relation" ? castData[ATTR_RELATION_SOURCE] ?? null : null;
+      const target = entityKind === "relation" ? castData[ATTR_RELATION_TARGET] ?? null : null;
+      const parent = castData[ATTR_PARENT] ?? null;
+      if (existing.length > 0) {
+        yield* sql`
+                  UPDATE objectMeta SET
+                    version = ${version},
+                    entityKind = ${entityKind},
+                    typeDxn = ${typeDxn},
+                    deleted = ${deleted},
+                    source = ${source},
+                    target = ${target},
+                    parent = ${parent}
+                  WHERE recordId = ${existing[0].recordId}
+                `;
+      } else {
+        yield* sql`
+                  INSERT INTO objectMeta (
+                    objectId, queueId, spaceId, documentId, 
+                    entityKind, typeDxn, deleted, source, target, parent, version
+                  ) VALUES (
+                    ${objectId}, ${queueId ?? ""}, ${spaceId}, ${documentId ?? ""}, 
+                    ${entityKind}, ${typeDxn}, ${deleted}, 
+                    ${source}, ${target}, ${parent}, ${version}
+                  )
+                `;
+      }
+    }), {
+      discard: true
+    });
+  }));
+  /**
+  * Look up `recordIds` for objects that are already stored in the ObjectMetaIndex.
+  * Mutates the objects in place.
+  */
+  lookupRecordIds = Effect3.fn("ObjectMetaIndex.lookupRecordIds")((objects) => Effect3.gen(function* () {
+    const sql = yield* SqlClient5.SqlClient;
+    for (const object of objects) {
+      const { spaceId, queueId, documentId, data } = object;
+      const objectId = data.id;
+      let result;
+      if (documentId) {
+        result = yield* sql`SELECT recordId FROM objectMeta WHERE spaceId = ${spaceId} AND documentId = ${documentId} AND objectId = ${objectId} LIMIT 1`;
+      } else if (queueId) {
+        result = yield* sql`SELECT recordId FROM objectMeta WHERE spaceId = ${spaceId} AND queueId = ${queueId} AND objectId = ${objectId} LIMIT 1`;
+      } else {
+        result = [];
+      }
+      if (result.length === 0) {
+        return yield* Effect3.die(new Error(`Object not found in ObjectMetaIndex: ${spaceId}/${documentId ?? queueId}/${objectId}`));
+      }
+      object.recordId = result[0].recordId;
+    }
+  }));
+  /**
+  * Look up object metadata by recordIds.
+  */
+  lookupByRecordIds = Effect3.fn("ObjectMetaIndex.lookupByRecordIds")((recordIds) => Effect3.gen(function* () {
+    if (recordIds.length === 0) {
+      return [];
+    }
+    const sql = yield* SqlClient5.SqlClient;
+    const rows = yield* sql`SELECT * FROM objectMeta WHERE ${sql.in("recordId", recordIds)}`;
+    return rows.map((row) => ({
+      ...row,
+      deleted: !!row.deleted
+    }));
+  }));
+  /**
+  * Query children by parent object ids.
+  */
+  queryChildren = Effect3.fn("ObjectMetaIndex.queryChildren")((query) => Effect3.gen(function* () {
+    if (query.parentIds.length === 0) {
+      return [];
+    }
+    const sql = yield* SqlClient5.SqlClient;
+    const rows = yield* sql`SELECT * FROM objectMeta WHERE spaceId IN ${sql.in(query.spaceId)} AND parent IN ${sql.in(query.parentIds.map((id) => DXN.fromLocalObjectId(id).toString()))}`;
+    return rows.map((row) => ({
+      ...row,
+      deleted: !!row.deleted
+    }));
+  }));
+};
+
+// src/indexes/reverse-ref-index.ts
+import * as SqlClient7 from "@effect/sql/SqlClient";
+import * as Effect4 from "effect/Effect";
+import * as Schema4 from "effect/Schema";
+import { EncodedReference, isEncodedReference } from "@dxos/echo-protocol";
+
+// src/utils.ts
+import * as Schema3 from "effect/Schema";
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/index-core/src/utils.ts";
+var EscapedPropPath = class extends Schema3.String.annotations({
+  title: "EscapedPropPath"
+}) {
+  static escape(path) {
+    return path.map((p) => p.toString().replaceAll("\\", "\\\\").replaceAll(".", "\\.")).join(".");
+  }
+  static unescape(path) {
+    const parts = [];
+    let current = "";
+    for (let i = 0; i < path.length; i++) {
+      if (path[i] === "\\") {
+        invariant(i + 1 < path.length && (path[i + 1] === "." || path[i + 1] === "\\"), "Malformed escaping.", {
+          F: __dxlog_file,
+          L: 34,
+          S: this,
+          A: [
+            "i + 1 < path.length && (path[i + 1] === '.' || path[i + 1] === '\\\\')",
+            "'Malformed escaping.'"
+          ]
+        });
+        current = current + path[i + 1];
+        i++;
+      } else if (path[i] === ".") {
+        parts.push(current);
+        current = "";
+      } else {
+        current += path[i];
+      }
+    }
+    parts.push(current);
+    return parts;
+  }
+};
+
+// src/indexes/reverse-ref-index.ts
+var extractReferences = (data) => {
+  const refs = [];
+  const visit = (path, value) => {
+    if (isEncodedReference(value)) {
+      const dxn = EncodedReference.toDXN(value);
+      const echoId = dxn.asEchoDXN()?.echoId;
+      if (!echoId) {
+        return;
+      }
+      refs.push({
+        path,
+        targetDxn: dxn.toString()
+      });
+    } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      for (const [key, v] of Object.entries(value)) {
+        visit([
+          ...path,
+          key
+        ], v);
+      }
+    } else if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        visit([
+          ...path,
+          String(i)
+        ], value[i]);
+      }
+    }
+  };
+  visit([], data);
+  return refs;
+};
+var ReverseRef = Schema4.Struct({
+  recordId: Schema4.Number,
+  targetDxn: Schema4.String,
+  /**
+  * Escaped property path within an object.
+  *
+  * Escaping rules:
+  *
+  * - '.' -> '\.'
+  * - '\' -> '\\'
+  * - contact with .
+  */
+  propPath: Schema4.String
+});
+var ReverseRefIndex = class {
+  migrate = Effect4.fn("ReverseRefIndex.migrate")(function* () {
+    const sql = yield* SqlClient7.SqlClient;
+    yield* sql`CREATE TABLE IF NOT EXISTS reverseRef (
+      recordId INTEGER NOT NULL,
+      targetDxn TEXT NOT NULL,
+      propPath TEXT NOT NULL,
+      PRIMARY KEY (recordId, targetDxn, propPath)
+    )`;
+    yield* sql`CREATE INDEX IF NOT EXISTS idx_reverse_ref_target ON reverseRef(targetDxn)`;
+  });
+  /**
+  * Query all references pointing to a target DXN.
+  */
+  query = Effect4.fn("ReverseRefIndex.query")(({ targetDxn }) => Effect4.gen(function* () {
+    const sql = yield* SqlClient7.SqlClient;
+    const rows = yield* sql`SELECT * FROM reverseRef WHERE targetDxn = ${targetDxn}`;
+    return rows;
+  }));
+  update = Effect4.fn("ReverseRefIndex.update")((objects) => Effect4.gen(function* () {
+    const sql = yield* SqlClient7.SqlClient;
+    yield* Effect4.forEach(objects, (object) => Effect4.gen(function* () {
+      const { recordId, data } = object;
+      if (recordId === null) {
+        yield* Effect4.die(new Error("ReverseRefIndex.update requires recordId to be set"));
+      }
+      yield* sql`DELETE FROM reverseRef WHERE recordId = ${recordId}`;
+      const refs = extractReferences(data);
+      yield* Effect4.forEach(refs, (ref) => sql`INSERT INTO reverseRef (recordId, targetDxn, propPath) VALUES (${recordId}, ${ref.targetDxn}, ${EscapedPropPath.escape(ref.path)})`, {
+        discard: true
+      });
+    }), {
+      discard: true
+    });
+  }));
+};
+
+// src/index-engine.ts
+var IndexEngine = class {
+  #tracker;
+  #objectMetaIndex;
+  #ftsIndex;
+  #reverseRefIndex;
+  constructor(params) {
+    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 Effect5.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 with rank.
+  */
+  queryText(query) {
+    return Effect5.gen(this, function* () {
+      return yield* this.#ftsIndex.query(query);
+    });
+  }
+  queryReverseRef(query) {
+    return this.#reverseRefIndex.query(query);
+  }
+  queryAll(query) {
+    return this.#objectMetaIndex.queryAll(query);
+  }
+  /**
+  * Query snapshots by recordIds.
+  * Used to load queue objects from indexed snapshots.
+  */
+  querySnapshotsJSON(recordIds) {
+    return this.#ftsIndex.querySnapshotsJSON(recordIds);
+  }
+  queryType(query) {
+    return this.#objectMetaIndex.query(query);
+  }
+  /**
+  * Query children by parent object ids.
+  */
+  queryChildren(query) {
+    return this.#objectMetaIndex.queryChildren(query);
+  }
+  queryTypes(query) {
+    return this.#objectMetaIndex.queryTypes(query);
+  }
+  queryRelations(query) {
+    return this.#objectMetaIndex.queryRelations(query);
+  }
+  lookupByRecordIds(recordIds) {
+    return this.#objectMetaIndex.lookupByRecordIds(recordIds);
+  }
+  update(dataSource, opts) {
+    return Effect5.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(Effect5.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, source, opts) {
+    return Effect5.gen(this, function* () {
+      const sqlTransaction = yield* SqlTransaction.SqlTransaction;
+      return yield* sqlTransaction.withTransaction(Effect5.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 ?? void 0
+        });
+        const { objects, cursors: updatedCursors } = yield* source.getChangedObjects(cursors, {
+          limit: opts.limit
+        });
+        if (objects.length === 0) {
+          return {
+            updated: 0,
+            done: true
+          };
+        }
+        yield* this.#objectMetaIndex.update(objects);
+        yield* this.#objectMetaIndex.lookupRecordIds(objects);
+        yield* index.update(objects);
+        yield* this.#tracker.updateCursors(updatedCursors.map((_) => ({
+          indexName: opts.indexName,
+          spaceId: _.spaceId,
+          sourceName: source.sourceName,
+          resourceId: _.resourceId,
+          cursor: _.cursor
+        })));
+        return {
+          updated: objects.length,
+          done: false
+        };
+      }));
+    }).pipe(Effect5.withSpan("IndexEngine.#update"));
+  }
+};
+export {
+  EscapedPropPath,
+  FtsIndex,
+  IndexEngine,
+  IndexTracker,
+  ObjectMetaIndex,
+  ReverseRefIndex
+};
+//# sourceMappingURL=index.mjs.map