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

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

@@ -2,19 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { getHeads } from '@automerge/automerge';
-import { type DocHandle, type DocumentId } from '@automerge/automerge-repo';
+import type * as SqlClient from '@effect/sql/SqlClient';
 import * as Schema from 'effect/Schema';
 
 import { DeferredTask, scheduleMicroTask, synchronized } from '@dxos/async';
 import { Stream } from '@dxos/codec-protobuf/stream';
-import { Context, Resource } from '@dxos/context';
+import { type Context, Resource } from '@dxos/context';
 import { raise } from '@dxos/debug';
-import { DatabaseDirectory, QueryAST } from '@dxos/echo-protocol';
-import { type IdToHeads, type Indexer, type ObjectSnapshot } from '@dxos/indexing';
+import { QueryAST } from '@dxos/echo-protocol';
+import { type RuntimeProvider } from '@dxos/effect';
+import { type IndexEngine } from '@dxos/index-core';
 import { log } from '@dxos/log';
-import { objectPointerCodec } from '@dxos/protocols';
-import { type IndexConfig } from '@dxos/protocols/proto/dxos/echo/indexing';
 import {
   type QueryRequest,
   type QueryResponse,
@@ -25,11 +23,12 @@ import { trace } from '@dxos/tracing';
 
 import { type AutomergeHost } from '../automerge';
 import { QueryExecutor } from '../query';
-
+import { type InvalidationHint, mergeHints } from './invalidation-hint';
 import type { SpaceStateManager } from './space-state-manager';
 
-export type QueryServiceParams = {
-  indexer: Indexer;
+export type QueryServiceProps = {
+  indexEngine: IndexEngine;
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
   automergeHost: AutomergeHost;
   spaceStateManager: SpaceStateManager;
 };
@@ -54,6 +53,16 @@ type ActiveQuery = {
   close: () => Promise<void>;
 };
 
+type QueryInvalidationStats = {
+  totalInvalidations: number;
+  catchAllInvalidations: number;
+  hintedInvalidations: number;
+  totalDirtyQueriesExecuted: number;
+  totalExecutionBatches: number;
+  averageDirtyPerBatch: number;
+  averageQueriesActive: number;
+};
+
 @trace.resource()
 export class QueryServiceImpl extends Resource implements QueryService {
   // TODO(dmaretskyi): We need to implement query deduping. Idle composer has 80 queries with only 10 being unique.
@@ -61,8 +70,22 @@ export class QueryServiceImpl extends Resource implements QueryService {
 
   private _updateQueries!: DeferredTask;
 
+  // 'all' = catch-all; null = no pending hint.
+  #pendingHint: InvalidationHint | 'all' | null = null;
+
+  // Diagnostic counters.
+  #stats: QueryInvalidationStats = {
+    totalInvalidations: 0,
+    catchAllInvalidations: 0,
+    hintedInvalidations: 0,
+    totalDirtyQueriesExecuted: 0,
+    totalExecutionBatches: 0,
+    averageDirtyPerBatch: 0,
+    averageQueriesActive: 0,
+  };
+
   // TODO(burdon): OK for options, but not params. Pass separately and type readonly here.
-  constructor(private readonly _params: QueryServiceParams) {
+  constructor(private readonly _params: QueryServiceProps) {
     super();
 
     trace.diagnostic({
@@ -78,12 +101,16 @@ export class QueryServiceImpl extends Resource implements QueryService {
         });
       },
     });
+
+    trace.diagnostic<QueryInvalidationStats>({
+      id: 'query-invalidation',
+      name: 'Query Invalidation',
+      fetch: async () => ({ ...this.#stats }),
+    });
   }
 
   override async _open(): Promise<void> {
-    this._params.indexer.updated.on(this._ctx, () => this.invalidateQueries());
-
-    this._updateQueries = new DeferredTask(this._ctx, this._executeQueries.bind(this));
+    this._updateQueries = new DeferredTask(this._ctx, () => this._executeQueries(this._ctx));
   }
 
   @synchronized
@@ -92,18 +119,23 @@ export class QueryServiceImpl extends Resource implements QueryService {
     await Promise.all(Array.from(this._queries).map((query) => query.close()));
   }
 
-  async setConfig(config: IndexConfig): Promise<void> {
-    await this._params.indexer.setConfig(config);
+  /**
+   * @deprecated No longer needed with SQL-based indexing.
+   */
+  async setConfig(): Promise<void> {
+    // No-op: SQL indexer doesn't need explicit configuration.
+  }
+
+  /**
+   * @deprecated No longer needed with SQL-based indexing.
+   */
+  async reindex(): Promise<void> {
+    // No-op: SQL indexer handles re-indexing automatically.
+    log.warn('reindex() is deprecated and no longer has any effect');
   }
 
   execQuery(request: QueryRequest): Stream<QueryResponse> {
     return new Stream<QueryResponse>(({ next, close, ctx }) => {
-      if (this._params.indexer.config?.enabled !== true) {
-        log.error('indexer is disabled', { config: this._params.indexer.config });
-        close();
-        return;
-      }
-
       const queryEntry = this._createQuery(ctx, request, next, close, close);
       scheduleMicroTask(ctx, async () => {
         await queryEntry.executor.open();
@@ -115,32 +147,20 @@ export class QueryServiceImpl extends Resource implements QueryService {
   }
 
   /**
-   * Re-index all loaded documents.
+   * Schedule re-execution of queries, optionally guided by a targeted hint.
+   * When called without a hint, all queries are marked dirty (catch-all invalidation).
    */
-  async reindex(): Promise<void> {
-    log('Reindexing all documents...');
-    const iterator = createDocumentsIterator(this._params.automergeHost);
-    const ids: IdToHeads = new Map();
-    for await (const documents of iterator()) {
-      for (const { id, heads } of documents) {
-        ids.set(id, heads);
-      }
-      if (ids.size % 100 === 0) {
-        log('Collected documents...', { count: ids.size });
+  invalidateQueries(hint?: InvalidationHint): void {
+    this.#stats.totalInvalidations++;
+    if (!hint) {
+      this.#pendingHint = 'all';
+      this.#stats.catchAllInvalidations++;
+    } else {
+      this.#stats.hintedInvalidations++;
+      if (this.#pendingHint !== 'all') {
+        this.#pendingHint = this.#pendingHint ? mergeHints(this.#pendingHint, hint) : hint;
       }
     }
-
-    log('Marking all documents as dirty...', { count: ids.size });
-    await this._params.indexer.reindex(ids);
-  }
-
-  /**
-   * Schedule re-execution of all queries.
-   */
-  invalidateQueries() {
-    for (const query of this._queries) {
-      query.dirty = true;
-    }
     this._updateQueries.schedule();
   }
 
@@ -154,7 +174,8 @@ export class QueryServiceImpl extends Resource implements QueryService {
     const parsedQuery = QueryAST.Query.pipe(Schema.decodeUnknownSync)(JSON.parse(request.query));
     const queryEntry: ActiveQuery = {
       executor: new QueryExecutor({
-        indexer: this._params.indexer,
+        indexEngine: this._params.indexEngine,
+        runtime: this._params.runtime,
         automergeHost: this._params.automergeHost,
         queryId: request.queryId ?? raise(new Error('query id required')),
         query: parsedQuery,
@@ -181,17 +202,39 @@ export class QueryServiceImpl extends Resource implements QueryService {
     return queryEntry;
   }
 
-  @trace.span({ showInBrowserTimeline: true })
-  private async _executeQueries() {
-    // TODO(dmaretskyi): How do we integrate this tracing info into the tracing API.
+  @trace.span({ showInBrowserTimeline: true, showInRemoteTracing: false })
+  private async _executeQueries(_ctx: Context) {
+    const hint = this.#pendingHint;
+    this.#pendingHint = null;
+
+    // Apply hint to determine which queries need re-execution.
+    for (const query of this._queries) {
+      if (!query.open) {
+        continue;
+      }
+      if (query.firstResult) {
+        // First run is always executed regardless of hint.
+        query.dirty = true;
+        continue;
+      }
+      if (hint === 'all') {
+        query.dirty = true;
+        continue;
+      }
+      if (hint && query.executor.matchesHint(hint)) {
+        query.dirty = true;
+      }
+    }
+
     const begin = performance.now();
-    let count = 0;
+    let dirtyCount = 0;
+    const activeCount = this._queries.size;
     await Promise.all(
       Array.from(this._queries).map(async (query) => {
         if (!query.dirty || !query.open) {
           return;
         }
-        count++;
+        dirtyCount++;
 
         try {
           const { changed } = await query.executor.execQuery();
@@ -201,68 +244,22 @@ export class QueryServiceImpl extends Resource implements QueryService {
             query.sendResults(query.executor.getResults());
           }
         } catch (err) {
-          log.catch(err);
+          log.catch(err, {
+            queryId: query.executor.queryId,
+            query: JSON.stringify(query.executor.query),
+          });
+          query.onError(err as Error);
         }
       }),
     );
-    log.verbose('executed queries', { count, duration: performance.now() - begin });
-  }
-}
-
-/**
- * Factory for `getAllDocuments` iterator.
- */
-// TODO(dmaretskyi): Get roots from echo-host.
-const createDocumentsIterator = (automergeHost: AutomergeHost) =>
-  /**
-   * Recursively get all object data blobs from loaded documents from Automerge Repo.
-   */
-  // TODO(mykola): Unload automerge handles after usage.
-  async function* getAllDocuments(): AsyncGenerator<ObjectSnapshot[], void, void> {
-    /** visited automerge handles */
-    const visited = new Set<string>();
-
-    async function* getObjectsFromHandle(handle: DocHandle<DatabaseDirectory>): AsyncGenerator<ObjectSnapshot[]> {
-      if (visited.has(handle.documentId) || !handle.isReady()) {
-        return;
-      }
-
-      const doc = handle.doc()!;
-      const spaceKey = DatabaseDirectory.getSpaceKey(doc) ?? undefined;
-      if (doc.objects) {
-        yield Object.entries(doc.objects as { [key: string]: any }).map(([objectId, object]) => {
-          return {
-            id: objectPointerCodec.encode({ documentId: handle.documentId, objectId, spaceKey }),
-            object,
-            heads: getHeads(doc),
-          };
-        });
-      }
-
-      if (doc.links) {
-        for (const id of Object.values(doc.links as { [echoId: string]: string })) {
-          const urlString = id.toString();
-          if (visited.has(urlString)) {
-            continue;
-          }
-          const linkHandle = await automergeHost.loadDoc<DatabaseDirectory>(Context.default(), urlString as DocumentId);
-          for await (const result of getObjectsFromHandle(linkHandle)) {
-            yield result;
-          }
-        }
-      }
 
-      visited.add(handle.documentId);
-    }
+    this.#stats.totalExecutionBatches++;
+    this.#stats.totalDirtyQueriesExecuted += dirtyCount;
+    this.#stats.averageDirtyPerBatch = this.#stats.totalDirtyQueriesExecuted / this.#stats.totalExecutionBatches;
+    this.#stats.averageQueriesActive =
+      (this.#stats.averageQueriesActive * (this.#stats.totalExecutionBatches - 1) + activeCount) /
+      this.#stats.totalExecutionBatches;
 
-    // TODO(mykola): Use list of roots instead of iterating over all handles.
-    for (const handle of Object.values(automergeHost.repo.handles)) {
-      if (visited.has(handle.documentId)) {
-        continue;
-      }
-      for await (const result of getObjectsFromHandle(handle)) {
-        yield result;
-      }
-      visited.add(handle.documentId);
-    }
-  };
+    log.verbose('executed queries', { dirty: dirtyCount, active: activeCount, duration: performance.now() - begin });
+  }
+}

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

@@ -0,0 +1,160 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as SqlClient from '@effect/sql/SqlClient';
+import * as Effect from 'effect/Effect';
+
+import { type Context } from '@dxos/context';
+import { EchoFeedCodec } from '@dxos/echo-protocol';
+import { type ObjectJSON } from '@dxos/echo/internal';
+import { RuntimeProvider } from '@dxos/effect';
+import { type FeedStore } from '@dxos/feed';
+import { type DataSourceCursor, type IndexDataSource, type IndexerObject } from '@dxos/index-core';
+import { failedInvariant } from '@dxos/invariant';
+import type { SpaceId } from '@dxos/keys';
+import { log } from '@dxos/log';
+import { FeedProtocol } from '@dxos/protocols';
+
+export type QueueDataSourceOptions = {
+  feedStore: FeedStore;
+  runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
+  /**
+   * Callback to get the list of space IDs that should be indexed.
+   */
+  getSpaceIds: () => SpaceId[];
+
+  /**
+   * Feed namespaces to index.
+   * @default [WellKnownNamespaces.data, WellKnownNamespaces.trace]
+   */
+  feedNamespaces?: string[];
+};
+
+export class QueueDataSource implements IndexDataSource {
+  readonly sourceName = 'queue';
+
+  /**
+   * Feed namespaces to index.
+   */
+  private readonly _feedNamespaces: string[];
+  private readonly _feedStore: FeedStore;
+  private readonly _runtime: RuntimeProvider.RuntimeProvider<SqlClient.SqlClient>;
+  private readonly _getSpaceIds: () => SpaceId[];
+
+  constructor(options: QueueDataSourceOptions) {
+    this._feedStore = options.feedStore;
+    this._runtime = options.runtime;
+    this._getSpaceIds = options.getSpaceIds;
+    this._feedNamespaces = options.feedNamespaces ?? [
+      FeedProtocol.WellKnownNamespaces.data,
+      FeedProtocol.WellKnownNamespaces.trace,
+    ];
+  }
+
+  getChangedObjects(
+    _ctx: Context,
+    cursors: DataSourceCursor[],
+    opts?: { limit?: number },
+  ): Effect.Effect<{ objects: IndexerObject[]; cursors: DataSourceCursor[] }> {
+    // For queue, the cursor is assumed to have:
+    // spaceId = set
+    // resourceId = null
+    // cursor = feed cursor
+
+    // We also add new cursors from all previously unindexed spaces.
+
+    return Effect.gen(this, function* () {
+      const objects: IndexerObject[] = [];
+      const updatedCursors: DataSourceCursor[] = [];
+
+      // Delete old cursors that did not have feed namespace set.
+      let augmentedCursors = [...cursors].filter((c) => c.resourceId !== null);
+      for (const spaceId of this._getSpaceIds()) {
+        for (const feedNamespace of this._feedNamespaces) {
+          if (!augmentedCursors.some((c) => c.spaceId === spaceId && c.resourceId === feedNamespace)) {
+            // Add a new cursor for this space starting from the beginning.
+            // Empty string cursor means "start from beginning".
+            augmentedCursors.push({
+              spaceId,
+              resourceId: feedNamespace,
+              cursor: '',
+            });
+          }
+        }
+      }
+
+      // Limit per call, but we might have multiple spaces.
+      // We should distribute limit or just fill up to limit.
+      let remainingLimit = opts?.limit ?? Infinity;
+
+      for (const cursor of augmentedCursors) {
+        if (remainingLimit <= 0) {
+          // Remaining cursors are not processed in this call.
+          updatedCursors.push(cursor);
+          continue;
+        }
+        if (!cursor.spaceId) {
+          // Ignore cursors without spaceId.
+          updatedCursors.push(cursor);
+          continue;
+        }
+        if (
+          FeedProtocol.WellKnownNamespaces.data !== cursor.resourceId &&
+          FeedProtocol.WellKnownNamespaces.trace !== cursor.resourceId
+        ) {
+          // TODO(dmaretskyi): Update/remove this check when adding new feed namespaces.
+          log.warn('Ignoring cursor with invaliding feed namespace', { namespace: cursor.resourceId });
+          // Ignore cursors with unknown resourceId.
+          updatedCursors.push(cursor);
+          continue;
+        }
+
+        // Empty string cursor means "start from beginning".
+        const currentCursor =
+          typeof cursor.cursor === 'string' && cursor.cursor !== ''
+            ? FeedProtocol.FeedCursor.make(cursor.cursor)
+            : undefined;
+
+        try {
+          const result = yield* this._feedStore.query({
+            spaceId: cursor.spaceId,
+            feedNamespace: cursor.resourceId,
+            cursor: currentCursor,
+            limit: remainingLimit,
+          });
+
+          // Process blocks
+          for (const block of result.blocks) {
+            try {
+              const data = EchoFeedCodec.decode(block.data) as ObjectJSON;
+
+              objects.push({
+                spaceId: cursor.spaceId,
+                queueId: block.feedId ?? failedInvariant(),
+                queueNamespace: cursor.resourceId,
+                documentId: null,
+                recordId: null,
+                data,
+                updatedAt: block.timestamp,
+              });
+            } catch (err) {
+              log.warn('Failed to parse block data for indexing', { spaceId: cursor.spaceId, err });
+            }
+          }
+
+          remainingLimit -= result.blocks.length;
+          updatedCursors.push({
+            spaceId: cursor.spaceId,
+            resourceId: cursor.resourceId,
+            cursor: result.nextCursor,
+          });
+        } catch (error) {
+          log.error('Error querying queue for indexing', { spaceId: cursor.spaceId, error });
+        }
+      }
+
+      return { objects, cursors: updatedCursors };
+    }).pipe(RuntimeProvider.provide(this._runtime), Effect.withSpan('QueueDataSource.getChangedObjects'), Effect.orDie);
+  }
+}

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

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

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

@@ -2,8 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type DocHandle, type DocumentId, interpretAsDocumentId } from '@automerge/automerge-repo';
-import isEqual from 'lodash.isequal';
+import { type DocumentId, type DocumentQuery, interpretAsDocumentId } from '@automerge/automerge-repo';
+import isEqual from 'fast-deep-equal';
 
 import { Event, UpdateScheduler } from '@dxos/async';
 import { Context, LifecycleState, Resource } from '@dxos/context';
@@ -32,6 +32,10 @@ export class SpaceStateManager extends Resource {
     return this._roots;
   }
 
+  get spaceIds(): SpaceId[] {
+    return Array.from(this._rootBySpace.keys());
+  }
+
   getRootByDocumentId(documentId: DocumentId): DatabaseRoot | undefined {
     return this._roots.get(documentId);
   }
@@ -49,13 +53,13 @@ export class SpaceStateManager extends Resource {
     return this._roots.get(documentId);
   }
 
-  async assignRootToSpace(spaceId: SpaceId, handle: DocHandle<DatabaseDirectory>): Promise<DatabaseRoot> {
+  async assignRootToSpace(spaceId: SpaceId, query: DocumentQuery<DatabaseDirectory>): Promise<DatabaseRoot> {
     let root: DatabaseRoot;
-    if (this._roots.has(handle.documentId)) {
-      root = this._roots.get(handle.documentId)!;
+    if (this._roots.has(query.documentId)) {
+      root = this._roots.get(query.documentId)!;
     } else {
-      root = new DatabaseRoot(handle);
-      this._roots.set(handle.documentId, root);
+      root = new DatabaseRoot(query);
+      this._roots.set(query.documentId, root);
     }
 
     if (this._rootBySpace.get(spaceId) === root.handle.documentId) {
@@ -73,8 +77,6 @@ export class SpaceStateManager extends Resource {
 
     this._perRootContext.set(root.handle.documentId, ctx);
 
-    await root.handle.whenReady();
-
     const documentListCheckScheduler = new UpdateScheduler(
       ctx,
       async () => {