@dxos/index-core 0.8.4-main.fcfe5033a5 → 0.9.0

package/src/indexes/{object-meta-index.ts → entity-meta-index.ts}

@@ -9,11 +9,28 @@ import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
 import { ATTR_DELETED, ATTR_PARENT, ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET, ATTR_TYPE } from '@dxos/echo/internal';
-import { DXN, type ObjectId, type SpaceId } from '@dxos/keys';
+import { DXN, EID, EntityId, SpaceId, URI } from '@dxos/keys';
 
 import type { IndexerObject } from './interface';
 import type { Index } from './interface';
 
+/**
+ * Normalizes an echo: EID to the local (unqualified) form so SQL comparisons are consistent.
+ * DB rows always store `echo:/<entityId>`; a space-qualified `echo://<space>/<entityId>` would
+ * otherwise miss every row for that type.
+ */
+const _normalizeTypeUri = (typeDXN: string): string => {
+  if (!typeDXN.startsWith('echo:')) {
+    return typeDXN;
+  }
+  const eid = EID.tryParse(typeDXN);
+  if (!eid) {
+    return typeDXN;
+  }
+  const entityId = EID.getEntityId(eid);
+  return entityId ? EID.make({ entityId }) : typeDXN;
+};
+
 const _escapeLikePrefix = (prefix: string) => {
   // Escape LIKE metacharacters in the *literal* prefix (we still append a wildcard for the version suffix).
   // Backslash is used as the ESCAPE character.
@@ -22,20 +39,27 @@ const _escapeLikePrefix = (prefix: string) => {
   return `${escaped}:%`;
 };
 
-export const ObjectMeta = Schema.Struct({
+export const EntityMeta = Schema.Struct({
   recordId: Schema.Number,
-  objectId: Schema.String,
+  objectId: EntityId,
+  /** Empty string for non-queue objects. */
   queueId: Schema.String,
-  spaceId: Schema.String,
+  /** Queue subspace namespace (e.g. 'data', 'trace'). Empty string for non-queue objects. */
+  queueNamespace: Schema.String,
+  spaceId: SpaceId,
   documentId: Schema.String,
   entityKind: Schema.String,
-  /** The versioned DXN of the type of the object. */
-  typeDxn: Schema.String,
+  /**
+   * Type identifier URI for the object — typename DXN for non-stored schemas,
+   * schema-as-object EID for stored (dynamic) schemas. Mirrors the value
+   * written into the object's `system.type`.
+   */
+  typeDXN: URI.Schema,
   deleted: Schema.Boolean,
-  source: Schema.NullOr(Schema.String),
-  target: Schema.NullOr(Schema.String),
+  source: Schema.NullOr(EID.Schema),
+  target: Schema.NullOr(EID.Schema),
   /** Parent object id (nullable). */
-  parent: Schema.NullOr(Schema.String),
+  parent: Schema.NullOr(EID.Schema),
   /** Monotonically increasing sequence number assigned on insert/update for tracking indexing order. */
   version: Schema.Number,
   /** Unix ms timestamp when the object was first indexed. */
@@ -43,7 +67,7 @@ export const ObjectMeta = Schema.Struct({
   /** Unix ms timestamp when the object was last re-indexed. */
   updatedAt: Schema.NullOr(Schema.Number),
 });
-export interface ObjectMeta extends Schema.Schema.Type<typeof ObjectMeta> {}
+export interface EntityMeta extends Schema.Schema.Type<typeof EntityMeta> {}
 
 /**
  * Builds a SQL condition for filtering by space and queue source.
@@ -76,18 +100,19 @@ const buildSourceCondition = (
   return sql.or(conditions);
 };
 
-export class ObjectMetaIndex implements Index {
-  migrate = Effect.fn('ObjectMetaIndex.runMigrations')(function* () {
+export class EntityMetaIndex implements Index {
+  migrate = Effect.fn('EntityMetaIndex.runMigrations')(function* () {
     const sql = yield* SqlClient.SqlClient;
 
     yield* sql`CREATE TABLE IF NOT EXISTS objectMeta (
       recordId INTEGER PRIMARY KEY AUTOINCREMENT,
       objectId TEXT NOT NULL,
       queueId TEXT NOT NULL DEFAULT '',
+      queueNamespace TEXT NOT NULL DEFAULT '',
       spaceId TEXT NOT NULL,
       documentId TEXT NOT NULL DEFAULT '',
       entityKind TEXT NOT NULL,
-      typeDxn TEXT NOT NULL,
+      typeDXN TEXT NOT NULL,
       deleted INTEGER NOT NULL,
       source TEXT,
       target TEXT,
@@ -102,30 +127,36 @@ export class ObjectMetaIndex implements Index {
     // Add timestamp columns for tables created before they were introduced.
     yield* Effect.catchAll(sql`ALTER TABLE objectMeta ADD COLUMN createdAt INTEGER`, () => Effect.void);
     yield* Effect.catchAll(sql`ALTER TABLE objectMeta ADD COLUMN updatedAt INTEGER`, () => Effect.void);
+    // Add queueNamespace column for tables created before it was introduced.
+    yield* Effect.catchAll(
+      sql`ALTER TABLE objectMeta ADD COLUMN queueNamespace TEXT NOT NULL DEFAULT ''`,
+      () => Effect.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_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)`;
     yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_updatedAt ON objectMeta(updatedAt)`;
     yield* sql`CREATE INDEX IF NOT EXISTS idx_object_index_createdAt ON objectMeta(createdAt)`;
   });
 
-  query = Effect.fn('ObjectMetaIndex.query')(
+  query = Effect.fn('EntityMetaIndex.query')(
     (
-      query: Pick<ObjectMeta, 'spaceId' | 'typeDxn'>,
-    ): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+      query: Pick<EntityMeta, 'spaceId' | 'typeDXN'>,
+    ): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
-        const parsedType = DXN.tryParse(query.typeDxn)?.asTypeDXN();
+        const normalizedTypeDXN = _normalizeTypeUri(query.typeDXN);
+        const parsedDxn = DXN.isDXN(normalizedTypeDXN) ? normalizedTypeDXN : undefined;
+        const hasNoVersion = parsedDxn !== undefined && DXN.getVersion(parsedDxn) === undefined;
 
         // SQLite stores booleans as integers, so we need to specify the raw row type.
-        const rows =
-          parsedType && parsedType.version === undefined
-            ? yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND (typeDxn = ${
-                query.typeDxn
-              } OR typeDxn LIKE ${_escapeLikePrefix(query.typeDxn)} ESCAPE '\\')`
-            : yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND typeDxn = ${query.typeDxn}`;
+        const rows = hasNoVersion
+          ? yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND (typeDXN = ${
+              normalizedTypeDXN
+            } OR typeDXN LIKE ${_escapeLikePrefix(normalizedTypeDXN)} ESCAPE '\\')`
+          : yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND typeDXN = ${normalizedTypeDXN}`;
         return rows.map((row) => ({
           ...row,
           deleted: !!row.deleted,
@@ -133,12 +164,12 @@ export class ObjectMetaIndex implements Index {
       }),
   );
 
-  queryAll = Effect.fn('ObjectMetaIndex.queryAll')(
+  queryAll = Effect.fn('EntityMetaIndex.queryAll')(
     (query: {
-      spaceIds: readonly ObjectMeta['spaceId'][];
+      spaceIds: readonly EntityMeta['spaceId'][];
       includeAllQueues?: boolean;
       queueIds?: readonly string[] | null;
-    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+    }): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         if (query.spaceIds.length === 0 && (!query.queueIds || query.queueIds.length === 0)) {
           return [];
@@ -151,7 +182,7 @@ export class ObjectMetaIndex implements Index {
           query.includeAllQueues ?? false,
           query.queueIds ?? null,
         );
-        const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition}`;
+        const rows = yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition}`;
         return rows.map((row) => ({
           ...row,
           deleted: !!row.deleted,
@@ -159,7 +190,7 @@ export class ObjectMetaIndex implements Index {
       }),
   );
 
-  queryTypes = Effect.fn('ObjectMetaIndex.queryTypes')(
+  queryTypes = Effect.fn('EntityMetaIndex.queryTypes')(
     ({
       spaceIds,
       typeDxns,
@@ -167,12 +198,12 @@ export class ObjectMetaIndex implements Index {
       includeAllQueues = false,
       queueIds = null,
     }: {
-      spaceIds: readonly ObjectMeta['spaceId'][];
-      typeDxns: readonly ObjectMeta['typeDxn'][];
+      spaceIds: readonly EntityMeta['spaceId'][];
+      typeDxns: readonly EntityMeta['typeDXN'][];
       inverted?: boolean;
       includeAllQueues?: boolean;
       queueIds?: readonly string[] | null;
-    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+    }): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         if (spaceIds.length === 0 && (!queueIds || queueIds.length === 0)) {
           return [];
@@ -185,7 +216,7 @@ export class ObjectMetaIndex implements Index {
 
           const sql = yield* SqlClient.SqlClient;
           const sourceCondition = buildSourceCondition(sql, spaceIds, includeAllQueues, queueIds);
-          const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition}`;
+          const rows = yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition}`;
           return rows.map((row) => ({
             ...row,
             deleted: !!row.deleted,
@@ -194,16 +225,19 @@ export class ObjectMetaIndex implements Index {
         const sql = yield* SqlClient.SqlClient;
         const sourceCondition = buildSourceCondition(sql, spaceIds, includeAllQueues, queueIds);
         const typeWhere = sql.or(
-          typeDxns.map((typeDxn) => {
-            const parsedType = DXN.tryParse(typeDxn)?.asTypeDXN();
-            return parsedType && parsedType.version === undefined
-              ? sql.or([sql`typeDxn = ${typeDxn}`, sql`typeDxn LIKE ${_escapeLikePrefix(typeDxn)} ESCAPE '\\'`])
-              : sql`typeDxn = ${typeDxn}`;
+          typeDxns.map((typeDXN) => {
+            const normalized = _normalizeTypeUri(typeDXN);
+            const parsedDxn = DXN.isDXN(normalized) ? normalized : undefined;
+            const hasNoVersion = parsedDxn !== undefined && DXN.getVersion(parsedDxn) === undefined;
+            const exactMatch = sql`typeDXN = ${normalized}`;
+            return hasNoVersion
+              ? sql.or([exactMatch, sql`typeDXN LIKE ${_escapeLikePrefix(normalized)} ESCAPE '\\'`])
+              : exactMatch;
           }),
         );
         const rows = inverted
-          ? yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition} AND NOT ${typeWhere}`
-          : yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition} AND ${typeWhere}`;
+          ? yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition} AND NOT ${typeWhere}`
+          : yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition} AND ${typeWhere}`;
         return rows.map((row) => ({
           ...row,
           deleted: !!row.deleted,
@@ -211,21 +245,21 @@ export class ObjectMetaIndex implements Index {
       }),
   );
 
-  queryRelations = Effect.fn('ObjectMetaIndex.queryRelations')(
+  queryRelations = Effect.fn('EntityMetaIndex.queryRelations')(
     ({
       endpoint,
       anchorDxns,
     }: {
       endpoint: 'source' | 'target';
       anchorDxns: readonly string[];
-    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+    }): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         if (anchorDxns.length === 0) {
           return [];
         }
         const sql = yield* SqlClient.SqlClient;
         const column = endpoint === 'source' ? 'source' : 'target';
-        const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE entityKind = 'relation' AND ${sql.in(
+        const rows = yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE entityKind = 'relation' AND ${sql.in(
           column,
           anchorDxns,
         )}`;
@@ -237,7 +271,7 @@ export class ObjectMetaIndex implements Index {
   );
 
   // TODO(dmaretskyi): Update recordId on objects so that we don't need to look it up separately.
-  update = Effect.fn('ObjectMetaIndex.update')(
+  update = Effect.fn('EntityMetaIndex.update')(
     (objects: IndexerObject[]): Effect.Effect<void, SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
@@ -246,7 +280,7 @@ export class ObjectMetaIndex implements Index {
           objects,
           (object) =>
             Effect.gen(function* () {
-              const { spaceId, queueId, documentId, data } = object;
+              const { spaceId, queueId, queueNamespace, documentId, data } = object;
 
               // Extract metadata (Logic emulating Echo APIs as strict imports are unavailable).
               const castData = data;
@@ -274,7 +308,9 @@ export class ObjectMetaIndex implements Index {
 
               // Extract metadata.
               const entityKind = castData[ATTR_RELATION_SOURCE] ? 'relation' : 'object';
-              const typeDxn = castData[ATTR_TYPE] ? String(castData[ATTR_TYPE]) : 'type';
+              // Type identifier as stored on `system.type`: a typename DXN for static schemas,
+              // an `echo:` EID for stored (dynamic) schemas.
+              const typeDXN = URI.make(castData[ATTR_TYPE] ? String(castData[ATTR_TYPE]) : 'type');
               const deleted = castData[ATTR_DELETED] ? 1 : 0;
               // Relations.
               const source = entityKind === 'relation' ? (castData[ATTR_RELATION_SOURCE] ?? null) : null;
@@ -282,32 +318,36 @@ export class ObjectMetaIndex implements Index {
               // Parent (nullable).
               const parent = castData[ATTR_PARENT] ?? null;
 
-              const sourceTimestamp = object.updatedAt;
+              const updatedAtTimestamp = object.updatedAt;
+              // Prefer the creation timestamp stored in the document (survives compaction/migrations).
+              // Fall back to the automerge-derived updatedAt for legacy objects that predate this field.
+              const createdAtTimestamp = object.createdAt ?? updatedAtTimestamp;
 
               if (existing.length > 0) {
                 yield* sql`
                   UPDATE objectMeta SET
                     version = ${version},
+                    queueNamespace = ${queueNamespace ?? ''},
                     entityKind = ${entityKind},
-                    typeDxn = ${typeDxn},
+                    typeDXN = ${typeDXN},
                     deleted = ${deleted},
                     source = ${source},
                     target = ${target},
                     parent = ${parent},
-                    updatedAt = ${sourceTimestamp}
+                    updatedAt = ${updatedAtTimestamp}
                   WHERE recordId = ${existing[0].recordId}
                 `;
               } else {
                 yield* sql`
                   INSERT INTO objectMeta (
-                    objectId, queueId, spaceId, documentId, 
-                    entityKind, typeDxn, deleted, source, target, parent, version,
+                    objectId, queueId, queueNamespace, spaceId, documentId,
+                    entityKind, typeDXN, deleted, source, target, parent, version,
                     createdAt, updatedAt
                   ) VALUES (
-                    ${objectId}, ${queueId ?? ''}, ${spaceId}, ${documentId ?? ''}, 
-                    ${entityKind}, ${typeDxn}, ${deleted}, 
+                    ${objectId}, ${queueId ?? ''}, ${queueNamespace ?? ''}, ${spaceId}, ${documentId ?? ''},
+                    ${entityKind}, ${typeDXN}, ${deleted},
                     ${source}, ${target}, ${parent}, ${version},
-                    ${sourceTimestamp}, ${sourceTimestamp}
+                    ${createdAtTimestamp}, ${updatedAtTimestamp}
                   )
                 `;
               }
@@ -318,10 +358,10 @@ export class ObjectMetaIndex implements Index {
   );
 
   /**
-   * Look up `recordIds` for objects that are already stored in the ObjectMetaIndex.
+   * Look up `recordIds` for objects that are already stored in the EntityMetaIndex.
    * Mutates the objects in place.
    */
-  lookupRecordIds = Effect.fn('ObjectMetaIndex.lookupRecordIds')(
+  lookupRecordIds = Effect.fn('EntityMetaIndex.lookupRecordIds')(
     (objects: IndexerObject[]): Effect.Effect<void, SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
@@ -346,7 +386,7 @@ export class ObjectMetaIndex implements Index {
           if (result.length === 0) {
             // TODO(mykola): Handle this case gracefully.
             return yield* Effect.die(
-              new Error(`Object not found in ObjectMetaIndex: ${spaceId}/${documentId ?? queueId}/${objectId}`),
+              new Error(`Object not found in EntityMetaIndex: ${spaceId}/${documentId ?? queueId}/${objectId}`),
             );
           }
           object.recordId = result[0].recordId;
@@ -357,15 +397,15 @@ export class ObjectMetaIndex implements Index {
   /**
    * Look up object metadata by recordIds.
    */
-  lookupByRecordIds = Effect.fn('ObjectMetaIndex.lookupByRecordIds')(
-    (recordIds: number[]): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+  lookupByRecordIds = Effect.fn('EntityMetaIndex.lookupByRecordIds')(
+    (recordIds: number[]): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         if (recordIds.length === 0) {
           return [];
         }
 
         const sql = yield* SqlClient.SqlClient;
-        const rows = yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sql.in('recordId', recordIds)}`;
+        const rows = yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sql.in('recordId', recordIds)}`;
 
         return rows.map((row) => ({
           ...row,
@@ -374,19 +414,42 @@ export class ObjectMetaIndex implements Index {
       }),
   );
 
+  /**
+   * Look up object metadata by object id across one or more spaces (space db and queue items).
+   */
+  queryObjectIds = Effect.fn('EntityMetaIndex.queryObjectIds')(
+    (query: {
+      spaceIds: readonly EntityMeta['spaceId'][];
+      objectIds: readonly EntityMeta['objectId'][];
+    }): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+      Effect.gen(function* () {
+        if (query.spaceIds.length === 0 || query.objectIds.length === 0) {
+          return [];
+        }
+
+        const sql = yield* SqlClient.SqlClient;
+        const rows =
+          yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sql.in('spaceId', query.spaceIds)} AND ${sql.in('objectId', query.objectIds)}`;
+        return rows.map((row) => ({
+          ...row,
+          deleted: !!row.deleted,
+        }));
+      }),
+  );
+
   /**
    * Look up object metadata by objectId, spaceId, and queueId.
    */
-  lookupByObjectId = Effect.fn('ObjectMetaIndex.lookupByObjectId')(
+  lookupByObjectId = Effect.fn('EntityMetaIndex.lookupByObjectId')(
     (query: {
       objectId: string;
       spaceId: string;
       queueId: string;
-    }): Effect.Effect<ObjectMeta | null, SqlError.SqlError, SqlClient.SqlClient> =>
+    }): Effect.Effect<EntityMeta | null, SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         const sql = yield* SqlClient.SqlClient;
         const rows =
-          yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND queueId = ${query.queueId} AND objectId = ${query.objectId} LIMIT 1`;
+          yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE spaceId = ${query.spaceId} AND queueId = ${query.queueId} AND objectId = ${query.objectId} LIMIT 1`;
 
         if (rows.length === 0) {
           return null;
@@ -402,7 +465,7 @@ export class ObjectMetaIndex implements Index {
   /**
    * Query objects by timestamp range.
    */
-  queryByTimeRange = Effect.fn('ObjectMetaIndex.queryByTimeRange')(
+  queryByTimeRange = Effect.fn('EntityMetaIndex.queryByTimeRange')(
     (query: {
       spaceIds: readonly string[];
       updatedAfter?: number;
@@ -411,7 +474,7 @@ export class ObjectMetaIndex implements Index {
       createdBefore?: number;
       includeAllQueues?: boolean;
       queueIds?: readonly string[] | null;
-    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+    }): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         if (query.spaceIds.length === 0 && (!query.queueIds || query.queueIds.length === 0)) {
           return [];
@@ -441,8 +504,8 @@ export class ObjectMetaIndex implements Index {
 
         const rows =
           timeConditions.length > 0
-            ? yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition} AND ${sql.and(timeConditions)}`
-            : yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition}`;
+            ? yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition} AND ${sql.and(timeConditions)}`
+            : yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sourceCondition}`;
 
         return rows.map((row) => ({
           ...row,
@@ -453,20 +516,26 @@ export class ObjectMetaIndex implements Index {
 
   /**
    * Query children by parent object ids.
+   * Matches both:
+   * - Objects whose `parent` field references one of the given parent ids (standard parent/child hierarchy).
+   * - Queue items whose `queueId` equals one of the parent ids (e.g. items inside a Feed, since a feed's queue
+   *   DXN uses the feed's object id as its queue id — see `Feed.getQueueUri`).
    */
-  queryChildren = Effect.fn('ObjectMetaIndex.queryChildren')(
+  queryChildren = Effect.fn('EntityMetaIndex.queryChildren')(
     (query: {
       spaceId: SpaceId[];
-      parentIds: ObjectId[];
-    }): Effect.Effect<readonly ObjectMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
+      parentIds: EntityId[];
+    }): Effect.Effect<readonly EntityMeta[], SqlError.SqlError, SqlClient.SqlClient> =>
       Effect.gen(function* () {
         if (query.parentIds.length === 0) {
           return [];
         }
 
         const sql = yield* SqlClient.SqlClient;
+        const parentDzns = query.parentIds.map((id) => EID.make({ entityId: id }));
+        const parentDxns = parentDzns;
         const rows =
-          yield* sql<ObjectMeta>`SELECT * FROM objectMeta WHERE spaceId IN ${sql.in(query.spaceId)} AND parent IN ${sql.in(query.parentIds.map((id) => DXN.fromLocalObjectId(id).toString()))}`;
+          yield* sql<EntityMeta>`SELECT * FROM objectMeta WHERE ${sql.in('spaceId', query.spaceId)} AND (${sql.in('parent', parentDxns)} OR ${sql.in('queueId', query.parentIds)})`;
 
         return rows.map((row) => ({
           ...row,