@dxos/echo-pipeline 0.8.2-main.fbd8ed0 → 0.8.2-staging.4d6ad0f

package/dist/lib/browser/index.mjs

@@ -1,4 +1,8 @@
 import "@dxos/node-std/globals";
+import {
+  filterMatchObject,
+  filterMatchValue
+} from "./chunk-TQJTKNMS.mjs";
 import {
   AuthExtension,
   AuthStatus,
@@ -21,7 +25,8 @@ import {
   mapTimeframeToFeedIndexes,
   startAfter,
   valueEncoding
-} from "./chunk-TPEBUDNJ.mjs";
+} from "./chunk-3XSXS5EX.mjs";
+import "./chunk-CGS2ULMK.mjs";
 
 // packages/core/echo/echo-pipeline/src/db-host/data-service.ts
 import { UpdateScheduler as UpdateScheduler2 } from "@dxos/async";
@@ -40,11 +45,7 @@ var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline
 var MAX_UPDATE_FREQ = 10;
 var DocumentsSynchronizer = class extends Resource {
   constructor(_params) {
-    super();
-    this._params = _params;
-    this._syncStates = /* @__PURE__ */ new Map();
-    this._pendingUpdates = /* @__PURE__ */ new Set();
-    this._sendUpdatesJob = void 0;
+    super(), this._params = _params, this._syncStates = /* @__PURE__ */ new Map(), this._pendingUpdates = /* @__PURE__ */ new Set(), this._sendUpdatesJob = void 0;
   }
   addDocuments(documentIds, retryCounter = 0) {
     if (retryCounter > 3) {
@@ -202,6 +203,7 @@ import { getBackend, getHeads, isAutomerge, equals as headsEquals, save } from "
 import { Repo, interpretAsDocumentId } from "@automerge/automerge-repo";
 import { Event as Event2, asyncTimeout } from "@dxos/async";
 import { Context, Resource as Resource4, cancelWithContext } from "@dxos/context";
+import { DatabaseDirectory } from "@dxos/echo-protocol";
 import { invariant as invariant3 } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
 import { log as log4 } from "@dxos/log";
@@ -484,13 +486,7 @@ function _ts_decorate2(decorators, target, key, desc) {
 var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/automerge/echo-network-adapter.ts";
 var EchoNetworkAdapter = class extends NetworkAdapter {
   constructor(_params) {
-    super();
-    this._params = _params;
-    this._replicators = /* @__PURE__ */ new Set();
-    this._connections = /* @__PURE__ */ new Map();
-    this._lifecycleState = LifecycleState.CLOSED;
-    this._connected = new Trigger();
-    this._ready = new Trigger();
+    super(), this._params = _params, this._replicators = /* @__PURE__ */ new Set(), this._connections = /* @__PURE__ */ new Map(), this._lifecycleState = LifecycleState.CLOSED, this._connected = new Trigger(), this._ready = new Trigger();
   }
   isReady() {
     return this._lifecycleState === LifecycleState.OPEN;
@@ -848,8 +844,7 @@ var HeadsStore = class {
 import { LifecycleState as LifecycleState2, Resource as Resource3 } from "@dxos/context";
 var LevelDBStorageAdapter = class extends Resource3 {
   constructor(_params) {
-    super();
-    this._params = _params;
+    super(), this._params = _params;
   }
   async load(keyArray) {
     try {
@@ -1190,7 +1185,7 @@ var AutomergeHost = class extends Resource4 {
     }
     const heads = getHeads(doc);
     this._headsStore.setHeads(handle.documentId, heads, batch);
-    const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+    const spaceKey = DatabaseDirectory.getSpaceKey(doc) ?? void 0;
     const objectIds = Object.keys(doc.objects ?? {});
     const encodedIds = objectIds.map((objectId) => objectPointerCodec.encode({
       documentId: handle.documentId,
@@ -1243,7 +1238,7 @@ var AutomergeHost = class extends Resource4 {
       await handle.whenReady();
     }
     if (handle && handle.isReady() && handle.doc()) {
-      const spaceKeyHex = getSpaceKeyFromDoc(handle.doc());
+      const spaceKeyHex = DatabaseDirectory.getSpaceKey(handle.doc());
       if (spaceKeyHex) {
         return PublicKey.from(spaceKeyHex);
       }
@@ -1258,7 +1253,10 @@ var AutomergeHost = class extends Resource4 {
   * Flush documents to disk.
   */
   async flush({ documentIds } = {}) {
-    const loadedDocuments = documentIds?.filter((documentId) => !!this._repo.handles[documentId]);
+    const loadedDocuments = documentIds?.filter((documentId) => {
+      const handle = this._repo.handles[documentId];
+      return handle && handle.isReady();
+    });
     await this._repo.flush(loadedDocuments);
   }
   async getHeads(documentIds) {
@@ -1373,7 +1371,7 @@ var AutomergeHost = class extends Resource4 {
       count: toReplicate.length
     }, {
       F: __dxlog_file4,
-      L: 556,
+      L: 557,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -1415,13 +1413,6 @@ _ts_decorate3([
 AutomergeHost = _ts_decorate3([
   trace2.resource()
 ], AutomergeHost);
-var getSpaceKeyFromDoc = (doc) => {
-  const rawSpaceKey = doc.access?.spaceKey ?? doc.experimental_spaceKey;
-  if (rawSpaceKey == null) {
-    return null;
-  }
-  return String(rawSpaceKey);
-};
 var waitForHeads = async (handle, heads) => {
   const unavailableHeads = new Set(heads);
   await handle.whenReady();
@@ -1440,7 +1431,7 @@ var changeIsPresentInDoc = (doc, changeHash) => {
 var decodeCollectionState = (state) => {
   invariant3(typeof state === "object" && state !== null, "Invalid state", {
     F: __dxlog_file4,
-    L: 617,
+    L: 608,
     S: void 0,
     A: [
       "typeof state === 'object' && state !== null",
@@ -1470,11 +1461,7 @@ var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipelin
 var DEFAULT_FACTORY = (params) => new AutomergeReplicator(...params);
 var MeshReplicatorConnection = class extends Resource5 {
   constructor(_params) {
-    super();
-    this._params = _params;
-    this.remoteDeviceKey = null;
-    this._remotePeerId = null;
-    this._isEnabled = false;
+    super(), this._params = _params, this.remoteDeviceKey = null, this._remotePeerId = null, this._isEnabled = false;
     let readableStreamController;
     this.readable = new ReadableStream({
       start: (controller) => {
@@ -2366,18 +2353,18 @@ var DataServiceImpl = class {
 };
 
 // packages/core/echo/echo-pipeline/src/db-host/echo-host.ts
-import { LifecycleState as LifecycleState4, Resource as Resource9 } from "@dxos/context";
+import { LifecycleState as LifecycleState5, Resource as Resource9 } from "@dxos/context";
 import { todo } from "@dxos/debug";
-import { createIdFromSpaceKey as createIdFromSpaceKey3, SpaceDocVersion as SpaceDocVersion3 } from "@dxos/echo-protocol";
+import { createIdFromSpaceKey as createIdFromSpaceKey2, SpaceDocVersion as SpaceDocVersion3 } from "@dxos/echo-protocol";
 import { IndexMetadataStore, IndexStore, Indexer } from "@dxos/indexing";
-import { invariant as invariant11 } from "@dxos/invariant";
+import { invariant as invariant13 } from "@dxos/invariant";
 import { IndexKind } from "@dxos/protocols/proto/dxos/echo/indexing";
-import { trace as trace6 } from "@dxos/tracing";
+import { trace as trace5 } from "@dxos/tracing";
 
 // packages/core/echo/echo-pipeline/src/db-host/documents-iterator.ts
 import * as A3 from "@automerge/automerge";
 import { Context as Context2 } from "@dxos/context";
-import { SpaceDocVersion } from "@dxos/echo-protocol";
+import { DatabaseDirectory as DatabaseDirectory2, SpaceDocVersion } from "@dxos/echo-protocol";
 import { invariant as invariant8 } from "@dxos/invariant";
 import { log as log8 } from "@dxos/log";
 import { ObjectPointerVersion, objectPointerCodec as objectPointerCodec2 } from "@dxos/protocols";
@@ -2432,7 +2419,7 @@ var createSelectedDocumentsIterator = (automergeHost) => (
         }
         let newId = id;
         if (objectPointerCodec2.getVersion(id) === ObjectPointerVersion.V0) {
-          const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+          const spaceKey = DatabaseDirectory2.getSpaceKey(doc) ?? void 0;
           newId = objectPointerCodec2.encode({
             documentId,
             objectId,
@@ -2464,223 +2451,1041 @@ var createSelectedDocumentsIterator = (automergeHost) => (
 
 // packages/core/echo/echo-pipeline/src/db-host/query-service.ts
 import { getHeads as getHeads3 } from "@automerge/automerge";
+import { Schema } from "effect";
 import { DeferredTask } from "@dxos/async";
 import { Stream as Stream2 } from "@dxos/codec-protobuf/stream";
 import { Context as Context4, Resource as Resource7 } from "@dxos/context";
-import { log as log9 } from "@dxos/log";
+import { raise } from "@dxos/debug";
+import { DatabaseDirectory as DatabaseDirectory4, QueryAST } from "@dxos/echo-protocol";
+import { log as log10 } from "@dxos/log";
 import { objectPointerCodec as objectPointerCodec4 } from "@dxos/protocols";
-import { trace as trace5 } from "@dxos/tracing";
+import { trace as trace4 } from "@dxos/tracing";
 
-// packages/core/echo/echo-pipeline/src/db-host/query-state.ts
-import { Context as Context3, LifecycleState as LifecycleState3, Resource as Resource6 } from "@dxos/context";
-import { createIdFromSpaceKey as createIdFromSpaceKey2 } from "@dxos/echo-protocol";
-import { invariant as invariant9 } from "@dxos/invariant";
+// packages/core/echo/echo-pipeline/src/query/query-executor.ts
+import { Match } from "effect";
+import { Context as Context3, ContextDisposedError, LifecycleState as LifecycleState3, Resource as Resource6 } from "@dxos/context";
+import { DatabaseDirectory as DatabaseDirectory3, isEncodedReference, ObjectStructure } from "@dxos/echo-protocol";
+import { EscapedPropPath } from "@dxos/indexing";
+import { invariant as invariant10 } from "@dxos/invariant";
 import { DXN, PublicKey as PublicKey3 } from "@dxos/keys";
+import { log as log9 } from "@dxos/log";
 import { objectPointerCodec as objectPointerCodec3 } from "@dxos/protocols";
-import { trace as trace4 } from "@dxos/tracing";
-import { isNonNullable as isNonNullable2 } from "@dxos/util";
-function _ts_decorate5(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-var __dxlog_file10 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/query-state.ts";
-var QueryState = class extends Resource6 {
-  get active() {
-    return this._lifecycleState === LifecycleState3.OPEN;
+import { getDeep, isNonNullable as isNonNullable2 } from "@dxos/util";
+
+// packages/core/echo/echo-pipeline/src/query/query-planner.ts
+import { invariant as invariant9 } from "@dxos/invariant";
+
+// packages/core/echo/echo-pipeline/src/query/errors.ts
+import { BaseError } from "@dxos/errors";
+var QueryError = class extends BaseError.extend("QUERY_ERROR") {
+};
+
+// packages/core/echo/echo-pipeline/src/query/plan.ts
+(function(QueryPlan2) {
+  QueryPlan2.Plan = Object.freeze({
+    make: (steps) => ({
+      steps
+    })
+  });
+  QueryPlan2.FilterStep = Object.freeze({
+    isNoop: (step) => {
+      switch (step.filter.type) {
+        case "object": {
+          return step.filter.typename === null && (step.filter.id === void 0 || step.filter.id.length === 0) && (step.filter.props === void 0 || Object.keys(step.filter.props).length === 0) && (step.filter.foreignKeys === void 0 || step.filter.foreignKeys.length === 0);
+        }
+        default:
+          return false;
+      }
+    }
+  });
+})(QueryPlan || (QueryPlan = {}));
+var QueryPlan;
+
+// packages/core/echo/echo-pipeline/src/query/query-planner.ts
+var __dxlog_file10 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/query/query-planner.ts";
+var DEFAULT_OPTIONS = {
+  defaultTextSearchKind: "full-text"
+};
+var QueryPlanner = class {
+  constructor(options) {
+    this._options = {
+      ...DEFAULT_OPTIONS,
+      ...options
+    };
   }
-  constructor(_params) {
-    super();
-    this._params = _params;
-    this._results = [];
-    this._firstRun = true;
-    this.metrics = {
-      objectsReturned: 0,
-      objectsReturnedFromIndex: 0,
-      documentsLoaded: 0,
-      executionTime: 0,
-      indexQueryTime: 0,
-      documentLoadTime: 0
+  createPlan(query) {
+    let plan = this._generate(query, {
+      ...DEFAULT_CONTEXT,
+      originalQuery: query
+    });
+    plan = this._optimizeEmptyFilters(plan);
+    plan = this._optimizeSoloUnions(plan);
+    return plan;
+  }
+  _generate(query, context) {
+    switch (query.type) {
+      case "options":
+        return this._generateOptionsClause(query, context);
+      case "select":
+        return this._generateSelectClause(query, context);
+      case "filter":
+        return this._generateFilterClause(query, context);
+      case "incoming-references":
+        return this._generateIncomingReferencesClause(query, context);
+      case "relation":
+        return this._generateRelationClause(query, context);
+      case "relation-traversal":
+        return this._generateRelationTraversalClause(query, context);
+      case "reference-traversal":
+        return this._generateReferenceTraversalClause(query, context);
+      case "union":
+        return this._generateUnionClause(query, context);
+      default:
+        throw new QueryError(`Unsupported query type: ${query.type}`, {
+          context: {
+            query: context.originalQuery
+          }
+        });
+    }
+  }
+  _generateOptionsClause(query, context) {
+    const newContext = {
+      ...context
     };
-    this.filter = _params.request.filter;
+    if (query.options.spaceIds) {
+      newContext.selectionSpaces = query.options.spaceIds;
+    }
+    if (query.options.deleted) {
+      newContext.deletedHandling = query.options.deleted;
+    }
+    return this._generate(query.query, newContext);
+  }
+  _generateSelectClause(query, context) {
+    return this._generateSelectionFromFilter(query.filter, context);
+  }
+  // TODO(dmaretskyi): This can be rewritten as a function of (filter[]) -> (selection ? undefined, rest: filter[]) that recurses onto itself.
+  // TODO(dmaretskyi): If the tip of the query ast is a [select, ...filter] shape we can reorder the filters so the query is most efficient.
+  _generateSelectionFromFilter(filter, context) {
+    switch (filter.type) {
+      case "object": {
+        if (context.selectionInverted && filter.id === void 0 && filter.typename === null && Object.keys(filter.props).length === 0) {
+          return QueryPlan.Plan.make([
+            {
+              _tag: "ClearWorkingSetStep"
+            },
+            ...this._generateDeletedHandlingSteps(context)
+          ]);
+        }
+        if (context.selectionInverted) {
+          throw new QueryError("Query too complex", {
+            context: {
+              query: context.originalQuery
+            }
+          });
+        }
+        if (filter.id && filter.id?.length > 0) {
+          return QueryPlan.Plan.make([
+            {
+              _tag: "SelectStep",
+              spaces: context.selectionSpaces,
+              selector: {
+                _tag: "IdSelector",
+                objectIds: filter.id
+              }
+            },
+            ...this._generateDeletedHandlingSteps(context),
+            {
+              _tag: "FilterStep",
+              filter: {
+                ...filter,
+                id: void 0
+              }
+            }
+          ]);
+        } else if (filter.typename) {
+          return QueryPlan.Plan.make([
+            {
+              _tag: "SelectStep",
+              spaces: context.selectionSpaces,
+              selector: {
+                _tag: "TypeSelector",
+                typename: [
+                  filter.typename
+                ],
+                inverted: false
+              }
+            },
+            ...this._generateDeletedHandlingSteps(context),
+            {
+              _tag: "FilterStep",
+              filter: {
+                ...filter,
+                typename: null
+              }
+            }
+          ]);
+        } else {
+          return QueryPlan.Plan.make([
+            {
+              _tag: "SelectStep",
+              spaces: context.selectionSpaces,
+              selector: {
+                _tag: "WildcardSelector"
+              }
+            },
+            ...this._generateDeletedHandlingSteps(context),
+            {
+              _tag: "FilterStep",
+              filter: {
+                ...filter
+              }
+            }
+          ]);
+        }
+      }
+      case "text-search": {
+        return QueryPlan.Plan.make([
+          {
+            _tag: "SelectStep",
+            spaces: context.selectionSpaces,
+            selector: {
+              _tag: "TextSelector",
+              text: filter.text,
+              searchKind: filter.searchKind ?? this._options.defaultTextSearchKind
+            }
+          },
+          ...this._generateDeletedHandlingSteps(context)
+        ]);
+      }
+      case "compare":
+        throw new QueryError("Query too complex", {
+          context: {
+            query: context.originalQuery
+          }
+        });
+      case "in":
+        throw new QueryError("Query too complex", {
+          context: {
+            query: context.originalQuery
+          }
+        });
+      case "range":
+        throw new QueryError("Query too complex", {
+          context: {
+            query: context.originalQuery
+          }
+        });
+      case "not":
+        return this._generateSelectionFromFilter(filter.filter, {
+          ...context,
+          selectionInverted: !context.selectionInverted
+        });
+      case "and":
+        throw new QueryError("Query too complex", {
+          context: {
+            query: context.originalQuery
+          }
+        });
+      case "or":
+        if (filter.filters.every(isTrivialTypenameFilter)) {
+          const typenames = filter.filters.map((f) => {
+            invariant9(f.type === "object" && f.typename !== null, void 0, {
+              F: __dxlog_file10,
+              L: 189,
+              S: this,
+              A: [
+                "f.type === 'object' && f.typename !== null",
+                ""
+              ]
+            });
+            return f.typename;
+          });
+          return QueryPlan.Plan.make([
+            {
+              _tag: "SelectStep",
+              spaces: context.selectionSpaces,
+              selector: {
+                _tag: "TypeSelector",
+                typename: typenames,
+                inverted: context.selectionInverted
+              }
+            },
+            ...this._generateDeletedHandlingSteps(context)
+          ]);
+        } else {
+          throw new QueryError("Query too complex", {
+            context: {
+              query: context.originalQuery
+            }
+          });
+        }
+      default:
+        throw new QueryError(`Unsupported filter type: ${filter.type}`, {
+          context: {
+            query: context.originalQuery
+          }
+        });
+    }
   }
-  getResults() {
-    return this._results;
+  _generateDeletedHandlingSteps(context) {
+    switch (context.deletedHandling) {
+      case "include":
+        return [];
+      case "exclude":
+        return [
+          {
+            _tag: "FilterDeletedStep",
+            mode: "only-non-deleted"
+          }
+        ];
+      case "only":
+        return [
+          {
+            _tag: "FilterDeletedStep",
+            mode: "only-deleted"
+          }
+        ];
+    }
   }
-  // https://github.com/open-telemetry/semantic-conventions/blob/main/docs/attributes-registry/db.md#generic-database-attributes
-  async execQuery() {
-    const filter = this._params.request.filter;
-    const beginQuery = performance.now();
-    const hits = filter.objectIds && filter.objectIds?.length > 0 ? [] : await this._params.indexer.execQuery(filterToIndexQuery(filter));
-    if (this._firstRun) {
-      this.metrics.indexQueryTime = performance.now() - beginQuery;
-    }
-    const beginFilter = performance.now();
-    const results = (await Promise.all(hits.map(async (result) => {
-      if (this._firstRun) {
-        this.metrics.objectsReturnedFromIndex++;
-      }
-      const { objectId, documentId, spaceKey: spaceKeyInIndex } = objectPointerCodec3.decode(result.id);
-      let spaceKey;
-      if (spaceKeyInIndex !== void 0) {
-        spaceKey = spaceKeyInIndex;
-      } else {
-        if (this._firstRun) {
-          this.metrics.documentsLoaded++;
+  _generateUnionClause(query, context) {
+    return QueryPlan.Plan.make([
+      {
+        _tag: "UnionStep",
+        plans: query.queries.map((query2) => this._generate(query2, context))
+      }
+    ]);
+  }
+  _generateReferenceTraversalClause(query, context) {
+    return QueryPlan.Plan.make([
+      ...this._generate(query.anchor, context).steps,
+      {
+        _tag: "TraverseStep",
+        traversal: {
+          _tag: "ReferenceTraversal",
+          direction: "outgoing",
+          property: query.property
         }
-        const handle = await this._params.automergeHost.loadDoc(Context3.default(void 0, {
-          F: __dxlog_file10,
-          L: 118
-        }), documentId);
-        if (this._ctx.disposed) {
-          return;
+      },
+      ...this._generateDeletedHandlingSteps(context)
+    ]);
+  }
+  _generateIncomingReferencesClause(query, context) {
+    return QueryPlan.Plan.make([
+      ...this._generate(query.anchor, context).steps,
+      {
+        _tag: "TraverseStep",
+        traversal: {
+          _tag: "ReferenceTraversal",
+          direction: "incoming",
+          property: query.property
+        }
+      },
+      ...this._generateDeletedHandlingSteps(context),
+      {
+        _tag: "FilterStep",
+        filter: {
+          type: "object",
+          typename: query.typename,
+          props: {}
         }
-        spaceKey = getSpaceKeyFromDoc(handle.doc());
       }
-      if (!spaceKey) {
-        return;
+    ]);
+  }
+  _generateRelationTraversalClause(query, context) {
+    switch (query.direction) {
+      case "source": {
+        return QueryPlan.Plan.make([
+          ...this._generate(query.anchor, context).steps,
+          createRelationTraversalStep("relation-to-source"),
+          ...this._generateDeletedHandlingSteps(context)
+        ]);
       }
-      if (this._params.request.filter.options?.spaces?.length && !this._params.request.filter.options.spaces.some((key) => key.equals(spaceKey))) {
-        return;
+      case "target": {
+        return QueryPlan.Plan.make([
+          ...this._generate(query.anchor, context).steps,
+          createRelationTraversalStep("relation-to-target"),
+          ...this._generateDeletedHandlingSteps(context)
+        ]);
       }
-      const spaceId = await createIdFromSpaceKey2(PublicKey3.from(spaceKey));
-      if (this._params.request.filter.options?.spaceIds?.length && !this._params.request.filter.options.spaceIds.includes(spaceId)) {
-        return;
+      case "both": {
+        const anchorPlan = this._generate(query.anchor, context);
+        return QueryPlan.Plan.make([
+          ...anchorPlan.steps,
+          {
+            _tag: "UnionStep",
+            plans: [
+              QueryPlan.Plan.make([
+                createRelationTraversalStep("relation-to-source")
+              ]),
+              QueryPlan.Plan.make([
+                createRelationTraversalStep("relation-to-target")
+              ])
+            ]
+          },
+          ...this._generateDeletedHandlingSteps(context)
+        ]);
       }
-      if (this._firstRun) {
-        this.metrics.objectsReturned++;
+    }
+  }
+  _generateRelationClause(query, context) {
+    switch (query.direction) {
+      case "outgoing": {
+        return QueryPlan.Plan.make([
+          ...this._generate(query.anchor, context).steps,
+          createRelationTraversalStep("source-to-relation"),
+          ...this._generateDeletedHandlingSteps(context),
+          {
+            _tag: "FilterStep",
+            filter: query.filter ?? NOOP_FILTER
+          }
+        ]);
+      }
+      case "incoming": {
+        return QueryPlan.Plan.make([
+          ...this._generate(query.anchor, context).steps,
+          createRelationTraversalStep("target-to-relation"),
+          ...this._generateDeletedHandlingSteps(context),
+          {
+            _tag: "FilterStep",
+            filter: query.filter ?? NOOP_FILTER
+          }
+        ]);
+      }
+      case "both": {
+        const anchorPlan = this._generate(query.anchor, context);
+        return QueryPlan.Plan.make([
+          ...anchorPlan.steps,
+          {
+            _tag: "UnionStep",
+            plans: [
+              QueryPlan.Plan.make([
+                createRelationTraversalStep("source-to-relation")
+              ]),
+              QueryPlan.Plan.make([
+                createRelationTraversalStep("target-to-relation")
+              ])
+            ]
+          },
+          ...this._generateDeletedHandlingSteps(context),
+          {
+            _tag: "FilterStep",
+            filter: query.filter ?? NOOP_FILTER
+          }
+        ]);
       }
-      return {
-        id: objectId,
-        documentId,
-        spaceId,
-        spaceKey: PublicKey3.from(spaceKey),
-        rank: result.rank
-      };
-    }))).filter(isNonNullable2);
-    if (this._firstRun) {
-      this.metrics.documentLoadTime = performance.now() - beginFilter;
     }
+  }
+  _generateFilterClause(query, context) {
+    return QueryPlan.Plan.make([
+      ...this._generate(query.selection, context).steps,
+      {
+        _tag: "FilterStep",
+        filter: query.filter
+      }
+    ]);
+  }
+  /**
+  * Removes filter steps that have no predicates.
+  */
+  _optimizeEmptyFilters(plan) {
+    return QueryPlan.Plan.make(plan.steps.filter((step) => {
+      if (step._tag === "FilterStep") {
+        return !QueryPlan.FilterStep.isNoop(step);
+      } else {
+        return true;
+      }
+    }).map((step) => {
+      if (step._tag === "UnionStep") {
+        return {
+          _tag: "UnionStep",
+          plans: step.plans.map((plan2) => this._optimizeEmptyFilters(plan2))
+        };
+      } else {
+        return step;
+      }
+    }));
+  }
+  /**
+  * Removes union steps that have only one child.
+  */
+  _optimizeSoloUnions(plan) {
+    return plan;
+  }
+};
+var DEFAULT_CONTEXT = {
+  originalQuery: null,
+  selectionSpaces: [],
+  deletedHandling: "exclude",
+  selectionInverted: false
+};
+var NOOP_FILTER = {
+  type: "object",
+  typename: null,
+  id: [],
+  props: {}
+};
+var createRelationTraversalStep = (direction) => ({
+  _tag: "TraverseStep",
+  traversal: {
+    _tag: "RelationTraversal",
+    direction
+  }
+});
+var isTrivialTypenameFilter = (filter) => {
+  return filter.type === "object" && filter.typename !== null && Object.keys(filter.props).length === 0 && (filter.id === void 0 || filter.id.length === 0) && (filter.foreignKeys === void 0 || filter.foreignKeys.length === 0);
+};
+
+// packages/core/echo/echo-pipeline/src/query/query-executor.ts
+var __dxlog_file11 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/query/query-executor.ts";
+var ExecutionTrace = Object.freeze({
+  makeEmpty: () => ({
+    name: "Empty",
+    details: "",
+    objectCount: 0,
+    documentsLoaded: 0,
+    indexHits: 0,
+    indexQueryTime: 0,
+    documentLoadTime: 0,
+    executionTime: 0,
+    children: []
+  }),
+  format: (trace6) => {
+    const go = (trace7, indent) => {
+      return [
+        `${" ".repeat(indent)} - ${trace7.name}(${trace7.details})`,
+        `${" ".repeat(indent)}   objects: ${trace7.objectCount}  docs: ${trace7.documentsLoaded}  index hits: ${trace7.indexHits} | total: ${trace7.executionTime.toFixed(0)}ms  index: ${trace7.indexQueryTime.toFixed(0)}ms  load: ${trace7.documentLoadTime.toFixed(0)}ms`,
+        "",
+        ...trace7.children.map((child) => go(child, indent + 2))
+      ].join("\n");
+    };
+    return go(trace6, 0);
+  }
+});
+var QueryExecutor = class extends Resource6 {
+  constructor(options) {
+    super();
+    this._trace = ExecutionTrace.makeEmpty();
+    this._lastResultSet = [];
+    this._indexer = options.indexer;
+    this._automergeHost = options.automergeHost;
+    this._spaceStateManager = options.spaceStateManager;
+    this._id = options.queryId;
+    this._query = options.query;
+    this._reactivity = options.reactivity;
+    const queryPlanner = new QueryPlanner();
+    this._plan = queryPlanner.createPlan(this._query);
+  }
+  get query() {
+    return this._query;
+  }
+  get plan() {
+    return this._plan;
+  }
+  get trace() {
+    return this._trace;
+  }
+  async _open(ctx) {
+  }
+  async _close(ctx) {
+  }
+  getResults() {
+    return this._lastResultSet.map((item) => ({
+      id: item.objectId,
+      documentId: item.documentId,
+      spaceId: item.spaceId,
+      // TODO(dmaretskyi): Plumb through the rank.
+      rank: 0
+    }));
+  }
+  async execQuery() {
+    invariant10(this._lifecycleState === LifecycleState3.OPEN, void 0, {
+      F: __dxlog_file11,
+      L: 171,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    const prevResultSet = this._lastResultSet;
+    const { workingSet, trace: trace6 } = await this._execPlan(this._plan, this._lastResultSet);
+    this._lastResultSet = workingSet;
+    trace6.name = "Root";
+    trace6.details = JSON.stringify({
+      id: this._id
+    });
+    this._trace = trace6;
+    const changed = prevResultSet.length !== workingSet.length || prevResultSet.some((item, index) => workingSet[index].objectId !== item.objectId || workingSet[index].spaceId !== item.spaceId || workingSet[index].documentId !== item.documentId);
+    return {
+      changed
+    };
+  }
+  async _execPlan(plan, workingSet) {
+    const trace6 = ExecutionTrace.makeEmpty();
+    for (const step of plan.steps) {
+      if (this._ctx.disposed) {
+        throw new ContextDisposedError();
+      }
+      const result = await this._execStep(step, workingSet);
+      workingSet = result.workingSet;
+      trace6.children.push(result.trace);
+    }
+    return {
+      workingSet,
+      trace: trace6
+    };
+  }
+  async _execStep(step, workingSet) {
     if (this._ctx.disposed) {
       return {
-        changed: false
+        workingSet,
+        trace: ExecutionTrace.makeEmpty()
       };
     }
-    const areResultsUnchanged = !this._firstRun && this._results.length === results.length && this._results.every((oldResult) => results.some((result) => result.id === oldResult.id)) && results.every((result) => this._results.some((oldResult) => oldResult.id === result.id));
-    if (this._firstRun) {
-      this.metrics.executionTime = performance.now() - beginQuery;
+    let newWorkingSet, trace6;
+    const begin = performance.now();
+    switch (step._tag) {
+      case "ClearWorkingSetStep":
+        newWorkingSet = [];
+        trace6 = ExecutionTrace.makeEmpty();
+        break;
+      case "SelectStep":
+        ({ workingSet: newWorkingSet, trace: trace6 } = await this._execSelectStep(step, workingSet));
+        break;
+      case "FilterStep":
+        ({ workingSet: newWorkingSet, trace: trace6 } = await this._execFilterStep(step, workingSet));
+        break;
+      case "FilterDeletedStep":
+        ({ workingSet: newWorkingSet, trace: trace6 } = await this._execFilterDeletedStep(step, workingSet));
+        break;
+      case "UnionStep":
+        ({ workingSet: newWorkingSet, trace: trace6 } = await this._execUnionStep(step, workingSet));
+        break;
+      case "TraverseStep":
+        ({ workingSet: newWorkingSet, trace: trace6 } = await this._execTraverseStep(step, workingSet));
+        break;
+      default:
+        throw new Error(`Unknown step type: ${step._tag}`);
     }
-    this._firstRun = false;
-    if (areResultsUnchanged) {
-      return {
-        changed: false
-      };
+    trace6.executionTime = performance.now() - begin;
+    return {
+      workingSet: newWorkingSet,
+      trace: trace6
+    };
+  }
+  async _execSelectStep(step, workingSet) {
+    workingSet = [
+      ...workingSet
+    ];
+    const trace6 = {
+      ...ExecutionTrace.makeEmpty(),
+      name: "Select",
+      details: JSON.stringify(step.selector)
+    };
+    switch (step.selector._tag) {
+      case "WildcardSelector": {
+        const beginIndexQuery = performance.now();
+        const indexHits = await this._indexer.execQuery({
+          typenames: [],
+          inverted: false
+        });
+        trace6.indexHits = +indexHits.length;
+        trace6.indexQueryTime += performance.now() - beginIndexQuery;
+        if (this._ctx.disposed) {
+          return {
+            workingSet,
+            trace: trace6
+          };
+        }
+        const documentLoadStart = performance.now();
+        const results = await this._loadDocumentsAfterIndexQuery(indexHits);
+        trace6.documentsLoaded += results.length;
+        trace6.documentLoadTime += performance.now() - documentLoadStart;
+        workingSet.push(...results.filter(isNonNullable2).filter((item) => step.spaces.includes(item.spaceId)));
+        trace6.objectCount = workingSet.length;
+        break;
+      }
+      case "IdSelector": {
+        const beginLoad = performance.now();
+        const items = await Promise.all(step.selector.objectIds.map((id) => this._loadFromDXN(DXN.fromLocalObjectId(id), {
+          sourceSpaceId: step.spaces[0]
+        })));
+        trace6.documentLoadTime += performance.now() - beginLoad;
+        workingSet.push(...items.filter(isNonNullable2));
+        trace6.objectCount = workingSet.length;
+        break;
+      }
+      case "TypeSelector": {
+        const beginIndexQuery = performance.now();
+        const indexHits = await this._indexer.execQuery({
+          typenames: step.selector.typename,
+          inverted: step.selector.inverted
+        });
+        trace6.indexHits = +indexHits.length;
+        trace6.indexQueryTime += performance.now() - beginIndexQuery;
+        if (this._ctx.disposed) {
+          return {
+            workingSet,
+            trace: trace6
+          };
+        }
+        const documentLoadStart = performance.now();
+        const results = await this._loadDocumentsAfterIndexQuery(indexHits);
+        trace6.documentsLoaded += results.length;
+        trace6.documentLoadTime += performance.now() - documentLoadStart;
+        workingSet.push(...results.filter(isNonNullable2).filter((item) => step.spaces.includes(item.spaceId)));
+        trace6.objectCount = workingSet.length;
+        break;
+      }
+      case "TextSelector": {
+        const beginIndexQuery = performance.now();
+        const indexHits = await this._indexer.execQuery({
+          typenames: [],
+          text: {
+            query: step.selector.text,
+            kind: Match.type().pipe(Match.withReturnType(), Match.when("full-text", () => "text"), Match.when("vector", () => "vector"), Match.orElseAbsurd)(step.selector.searchKind)
+          }
+        });
+        trace6.indexHits = +indexHits.length;
+        trace6.indexQueryTime += performance.now() - beginIndexQuery;
+        if (this._ctx.disposed) {
+          return {
+            workingSet,
+            trace: trace6
+          };
+        }
+        const documentLoadStart = performance.now();
+        const results = await this._loadDocumentsAfterIndexQuery(indexHits);
+        trace6.documentsLoaded += results.length;
+        trace6.documentLoadTime += performance.now() - documentLoadStart;
+        workingSet.push(...results.filter(isNonNullable2).filter((item) => step.spaces.includes(item.spaceId)));
+        trace6.objectCount = workingSet.length;
+        break;
+      }
+      default:
+        throw new Error(`Unknown selector type: ${step.selector._tag}`);
     }
-    this._results = results;
     return {
-      changed: true
+      workingSet,
+      trace: trace6
     };
   }
-};
-_ts_decorate5([
-  trace4.info({
-    depth: null
-  })
-], QueryState.prototype, "filter", void 0);
-_ts_decorate5([
-  trace4.info()
-], QueryState.prototype, "metrics", void 0);
-_ts_decorate5([
-  trace4.info()
-], QueryState.prototype, "active", null);
-_ts_decorate5([
-  trace4.span({
-    showInBrowserTimeline: true,
-    op: "db.query",
-    attributes: {
-      "db.system": "echo"
+  async _execFilterStep(step, workingSet) {
+    const result = workingSet.filter((item) => filterMatchObject(step.filter, {
+      id: item.objectId,
+      spaceId: item.spaceId,
+      doc: item.doc
+    }));
+    return {
+      workingSet: result,
+      trace: {
+        ...ExecutionTrace.makeEmpty(),
+        name: "Filter",
+        details: JSON.stringify(step.filter),
+        objectCount: result.length
+      }
+    };
+  }
+  async _execFilterDeletedStep(step, workingSet) {
+    const expected = step.mode === "only-deleted";
+    const result = workingSet.filter((item) => ObjectStructure.isDeleted(item.doc) === expected);
+    return {
+      workingSet: result,
+      trace: {
+        ...ExecutionTrace.makeEmpty(),
+        name: "FilterDeleted",
+        details: step.mode,
+        objectCount: result.length
+      }
+    };
+  }
+  // TODO(dmaretskyi): This needs to be completed.
+  async _execTraverseStep(step, workingSet) {
+    const trace6 = {
+      ...ExecutionTrace.makeEmpty(),
+      name: "Traverse",
+      details: JSON.stringify(step.traversal)
+    };
+    const newWorkingSet = [];
+    switch (step.traversal._tag) {
+      case "ReferenceTraversal": {
+        switch (step.traversal.direction) {
+          case "outgoing": {
+            const property = EscapedPropPath.unescape(step.traversal.property);
+            const refs = workingSet.map((item) => {
+              const ref = getDeep(item.doc.data, property);
+              if (!isEncodedReference(ref)) {
+                return null;
+              }
+              try {
+                return {
+                  ref: DXN.parse(ref["/"]),
+                  spaceId: item.spaceId
+                };
+              } catch {
+                log9.warn("Invalid reference", {
+                  ref: ref["/"]
+                }, {
+                  F: __dxlog_file11,
+                  L: 421,
+                  S: this,
+                  C: (f, a) => f(...a)
+                });
+                return null;
+              }
+            }).filter(isNonNullable2);
+            const beginLoad = performance.now();
+            const items = await Promise.all(refs.map(({ ref, spaceId }) => this._loadFromDXN(ref, {
+              sourceSpaceId: spaceId
+            })));
+            trace6.documentLoadTime += performance.now() - beginLoad;
+            newWorkingSet.push(...items.filter(isNonNullable2));
+            trace6.objectCount = newWorkingSet.length;
+            break;
+          }
+          case "incoming": {
+            const indexHits = await this._indexer.execQuery({
+              typenames: [],
+              inverted: false,
+              graph: {
+                kind: "inbound-reference",
+                property: step.traversal.property,
+                anchors: workingSet.map((item) => item.objectId)
+              }
+            });
+            trace6.indexHits += indexHits.length;
+            const documentLoadStart = performance.now();
+            const results = await this._loadDocumentsAfterIndexQuery(indexHits);
+            trace6.documentsLoaded += results.length;
+            trace6.documentLoadTime += performance.now() - documentLoadStart;
+            newWorkingSet.push(...results.filter(isNonNullable2));
+            trace6.objectCount = newWorkingSet.length;
+            break;
+          }
+        }
+        break;
+      }
+      case "RelationTraversal": {
+        switch (step.traversal.direction) {
+          case "relation-to-source":
+          case "relation-to-target": {
+            const refs = workingSet.map((item) => {
+              const ref = step.traversal.direction === "relation-to-source" ? ObjectStructure.getRelationSource(item.doc) : ObjectStructure.getRelationTarget(item.doc);
+              if (!isEncodedReference(ref)) {
+                return null;
+              }
+              try {
+                return {
+                  ref: DXN.parse(ref["/"]),
+                  spaceId: item.spaceId
+                };
+              } catch {
+                log9.warn("Invalid reference", {
+                  ref: ref["/"]
+                }, {
+                  F: __dxlog_file11,
+                  L: 483,
+                  S: this,
+                  C: (f, a) => f(...a)
+                });
+                return null;
+              }
+            }).filter(isNonNullable2);
+            const beginLoad = performance.now();
+            const items = await Promise.all(refs.map(({ ref, spaceId }) => this._loadFromDXN(ref, {
+              sourceSpaceId: spaceId
+            })));
+            trace6.documentLoadTime += performance.now() - beginLoad;
+            newWorkingSet.push(...items.filter(isNonNullable2));
+            trace6.objectCount = newWorkingSet.length;
+            break;
+          }
+          case "source-to-relation":
+          case "target-to-relation": {
+            const indexHits = await this._indexer.execQuery({
+              typenames: [],
+              inverted: false,
+              graph: {
+                kind: step.traversal.direction === "source-to-relation" ? "relation-source" : "relation-target",
+                anchors: workingSet.map((item) => item.objectId),
+                property: null
+              }
+            });
+            trace6.indexHits += indexHits.length;
+            const documentLoadStart = performance.now();
+            const results = await this._loadDocumentsAfterIndexQuery(indexHits);
+            trace6.documentsLoaded += results.length;
+            trace6.documentLoadTime += performance.now() - documentLoadStart;
+            newWorkingSet.push(...results.filter(isNonNullable2));
+            trace6.objectCount = newWorkingSet.length;
+            break;
+          }
+        }
+        break;
+      }
+      default:
+        throw new Error(`Unknown traversal type: ${step.traversal._tag}`);
     }
-  })
-], QueryState.prototype, "execQuery", null);
-QueryState = _ts_decorate5([
-  trace4.resource()
-], QueryState);
-var filterToIndexQuery = (filter) => {
-  const { type = [], or = [] } = filter;
-  invariant9(!(type.length > 0 && or.length > 0), "Cannot mix type and or filters.", {
-    F: __dxlog_file10,
-    L: 194,
-    S: void 0,
-    A: [
-      "!(type.length > 0 && or.length > 0)",
-      "'Cannot mix type and or filters.'"
-    ]
-  });
-  invariant9(or.every((subFilter) => !((subFilter.type ?? []).length > 0 && (subFilter.or ?? []).length > 0)), "Cannot mix type and or filters.", {
-    F: __dxlog_file10,
-    L: 195,
-    S: void 0,
-    A: [
-      "or.every((subFilter) => !((subFilter.type ?? []).length > 0 && (subFilter.or ?? []).length > 0))",
-      "'Cannot mix type and or filters.'"
-    ]
-  });
-  if (type.length > 0 || or.length > 0 && (or ?? []).every((subFilter) => !subFilter.not && subFilter.type)) {
     return {
-      typenames: type.length > 0 ? type.map((type2) => dxnToIndexerTypename(DXN.parse(type2))) : or.flatMap((f) => (f.type ?? []).map((type2) => dxnToIndexerTypename(DXN.parse(type2))) ?? []).filter(isNonNullable2),
-      inverted: filter.not
+      workingSet: newWorkingSet,
+      trace: trace6
+    };
+  }
+  async _execUnionStep(step, workingSet) {
+    const results = /* @__PURE__ */ new Map();
+    const resultSets = await Promise.all(step.plans.map((plan) => this._execPlan(plan, [
+      ...workingSet
+    ])));
+    const trace6 = {
+      ...ExecutionTrace.makeEmpty(),
+      name: "Union"
     };
-  } else {
+    for (const resultSet of resultSets) {
+      for (const item of resultSet.workingSet) {
+        results.set(`${item.spaceId}:${item.documentId}:${item.objectId}`, item);
+      }
+      trace6.children.push(resultSet.trace);
+    }
     return {
-      typenames: []
+      workingSet: [
+        ...results.values()
+      ],
+      trace: trace6
     };
   }
-};
-var dxnToIndexerTypename = (dxn) => {
-  switch (dxn.kind) {
-    case DXN.kind.TYPE:
-      return dxn.parts[0];
-    case DXN.kind.ECHO:
-      return dxn.parts[1];
-    default:
-      throw new Error(`Invalid DXN kind: ${dxn.kind}`);
+  async _loadDocumentsAfterIndexQuery(indexHits) {
+    return Promise.all(indexHits.map(async (hit) => {
+      return this._loadFromIndexHit(hit);
+    }));
+  }
+  async _loadFromIndexHit(hit) {
+    const { objectId, documentId, spaceKey: spaceKeyInIndex } = objectPointerCodec3.decode(hit.id);
+    const handle = await this._automergeHost.loadDoc(Context3.default(void 0, {
+      F: __dxlog_file11,
+      L: 571
+    }), documentId);
+    const doc = handle.doc();
+    if (!doc) {
+      return null;
+    }
+    const spaceKey = spaceKeyInIndex ?? DatabaseDirectory3.getSpaceKey(doc);
+    if (!spaceKey) {
+      return null;
+    }
+    const object = DatabaseDirectory3.getInlineObject(doc, objectId);
+    if (!object) {
+      return null;
+    }
+    return {
+      objectId,
+      documentId,
+      spaceId: await createIdFromSpaceKey(PublicKey3.from(spaceKey)),
+      doc: object
+    };
+  }
+  async _loadFromDXN(dxn, { sourceSpaceId }) {
+    const echoDxn = dxn.asEchoDXN();
+    if (!echoDxn) {
+      log9.warn("unable to resolve DXN", {
+        dxn
+      }, {
+        F: __dxlog_file11,
+        L: 598,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return null;
+    }
+    const spaceId = echoDxn.spaceId ?? sourceSpaceId;
+    const spaceRoot = this._spaceStateManager.getRootBySpaceId(spaceId);
+    if (!spaceRoot) {
+      log9.warn("no space state found for", {
+        spaceId
+      }, {
+        F: __dxlog_file11,
+        L: 606,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return null;
+    }
+    const dbDirectory = spaceRoot.doc();
+    if (!dbDirectory) {
+      log9.warn("no space state found for", {
+        spaceId
+      }, {
+        F: __dxlog_file11,
+        L: 611,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return null;
+    }
+    const inlineObject = DatabaseDirectory3.getInlineObject(dbDirectory, echoDxn.echoId);
+    if (inlineObject) {
+      return {
+        objectId: echoDxn.echoId,
+        documentId: spaceRoot.documentId,
+        spaceId,
+        doc: inlineObject
+      };
+    }
+    const link = DatabaseDirectory3.getLink(dbDirectory, echoDxn.echoId);
+    if (!link) {
+      return null;
+    }
+    const handle = await this._automergeHost.loadDoc(Context3.default(void 0, {
+      F: __dxlog_file11,
+      L: 630
+    }), link);
+    const doc = handle.doc();
+    if (!doc) {
+      return null;
+    }
+    const object = DatabaseDirectory3.getInlineObject(doc, echoDxn.echoId);
+    if (!object) {
+      return null;
+    }
+    return {
+      objectId: echoDxn.echoId,
+      documentId: handle.documentId,
+      spaceId,
+      doc: object
+    };
   }
 };
 
 // packages/core/echo/echo-pipeline/src/db-host/query-service.ts
-var __dxlog_file11 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/query-service.ts";
+var __dxlog_file12 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/query-service.ts";
 var QueryServiceImpl = class extends Resource7 {
   // TODO(burdon): OK for options, but not params. Pass separately and type readonly here.
   constructor(_params) {
-    super();
-    this._params = _params;
-    this._queries = /* @__PURE__ */ new Set();
-    this._updateQueries = new DeferredTask(this._ctx, async () => {
+    super(), this._params = _params, this._queries = /* @__PURE__ */ new Set(), this._updateQueries = new DeferredTask(this._ctx, async () => {
       await Promise.all(Array.from(this._queries).map(async (query) => {
         try {
-          const { changed } = await query.state.execQuery();
+          const { changed } = await query.executor.execQuery();
           if (changed) {
-            query.sendResults(query.state.getResults());
+            query.sendResults(query.executor.getResults());
           }
         } catch (err) {
-          log9.catch(err, void 0, {
-            F: __dxlog_file11,
-            L: 53,
+          log10.catch(err, void 0, {
+            F: __dxlog_file12,
+            L: 57,
             S: this,
             C: (f, a) => f(...a)
           });
         }
       }));
     });
-    trace5.diagnostic({
+    trace4.diagnostic({
       id: "active-queries",
       name: "Active Queries",
       fetch: () => {
         return Array.from(this._queries).map((query) => {
           return {
-            filter: JSON.stringify(query.state.filter),
-            metrics: query.state.metrics
+            query: JSON.stringify(query.executor.query),
+            plan: JSON.stringify(query.executor.plan),
+            trace: JSON.stringify(query.executor.trace)
           };
         });
       }
@@ -2693,24 +3498,19 @@ var QueryServiceImpl = class extends Resource7 {
     await Promise.all(Array.from(this._queries).map((query) => query.close()));
   }
   async setConfig(config) {
-    if (this._params.indexer.initialized) {
-      log9.warn("Indexer already initialized.", void 0, {
-        F: __dxlog_file11,
-        L: 87,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    void this._params.indexer.setConfig(config);
+    await this._params.indexer.setConfig(config);
   }
   execQuery(request) {
     return new Stream2(({ next, close, ctx }) => {
-      const query = {
-        state: new QueryState({
+      const parsedQuery = QueryAST.Query.pipe(Schema.decodeUnknownSync)(JSON.parse(request.query));
+      const queryEntry = {
+        executor: new QueryExecutor({
           indexer: this._params.indexer,
           automergeHost: this._params.automergeHost,
-          request
+          queryId: request.queryId ?? raise(new Error("query id required")),
+          query: parsedQuery,
+          reactivity: request.reactivity,
+          spaceStateManager: this._params.spaceStateManager
         }),
         sendResults: (results) => {
           if (ctx.disposed) {
@@ -2723,37 +3523,30 @@ var QueryServiceImpl = class extends Resource7 {
         },
         close: async () => {
           close();
-          await query.state.close();
-          this._queries.delete(query);
+          await queryEntry.executor.close();
+          this._queries.delete(queryEntry);
         }
       };
-      this._queries.add(query);
+      this._queries.add(queryEntry);
       queueMicrotask(async () => {
-        await query.state.open();
+        await queryEntry.executor.open();
         try {
-          const { changed } = await query.state.execQuery();
-          if (changed) {
-            query.sendResults(query.state.getResults());
-          }
+          await queryEntry.executor.execQuery();
+          queryEntry.sendResults(queryEntry.executor.getResults());
         } catch (error) {
-          log9.catch(error, void 0, {
-            F: __dxlog_file11,
-            L: 124,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          close(error);
         }
       });
-      return query.close;
+      return queryEntry.close;
     });
   }
   /**
   * Re-index all loaded documents.
   */
   async reindex() {
-    log9.info("Reindexing all documents...", void 0, {
-      F: __dxlog_file11,
-      L: 136,
+    log10.info("Reindexing all documents...", void 0, {
+      F: __dxlog_file12,
+      L: 141,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2764,21 +3557,21 @@ var QueryServiceImpl = class extends Resource7 {
         ids.set(id, heads);
       }
       if (ids.size % 100 === 0) {
-        log9.info("Collected documents...", {
+        log10.info("Collected documents...", {
           count: ids.size
         }, {
-          F: __dxlog_file11,
-          L: 144,
+          F: __dxlog_file12,
+          L: 149,
           S: this,
           C: (f, a) => f(...a)
         });
       }
     }
-    log9.info("Marking all documents as dirty...", {
+    log10.info("Marking all documents as dirty...", {
       count: ids.size
     }, {
-      F: __dxlog_file11,
-      L: 148,
+      F: __dxlog_file12,
+      L: 153,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2797,7 +3590,7 @@ var createDocumentsIterator = (automergeHost) => (
         return;
       }
       const doc = handle.doc();
-      const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+      const spaceKey = DatabaseDirectory4.getSpaceKey(doc) ?? void 0;
       if (doc.objects) {
         yield Object.entries(doc.objects).map(([objectId, object]) => {
           return {
@@ -2818,8 +3611,8 @@ var createDocumentsIterator = (automergeHost) => (
             continue;
           }
           const linkHandle = await automergeHost.loadDoc(Context4.default(void 0, {
-            F: __dxlog_file11,
-            L: 190
+            F: __dxlog_file12,
+            L: 195
           }), urlString);
           for await (const result of getObjectsFromHandle(linkHandle)) {
             yield result;
@@ -2844,17 +3637,18 @@ var createDocumentsIterator = (automergeHost) => (
 import { interpretAsDocumentId as interpretAsDocumentId3 } from "@automerge/automerge-repo";
 import isEqual from "lodash.isequal";
 import { Event as Event3, UpdateScheduler as UpdateScheduler3 } from "@dxos/async";
-import { Resource as Resource8, Context as Context5 } from "@dxos/context";
+import { Resource as Resource8, Context as Context5, LifecycleState as LifecycleState4 } from "@dxos/context";
+import { invariant as invariant12 } from "@dxos/invariant";
 
 // packages/core/echo/echo-pipeline/src/db-host/database-root.ts
 import { interpretAsDocumentId as interpretAsDocumentId2 } from "@automerge/automerge-repo";
-import { SpaceDocVersion as SpaceDocVersion2 } from "@dxos/echo-protocol";
-import { invariant as invariant10 } from "@dxos/invariant";
+import { DatabaseDirectory as DatabaseDirectory5, SpaceDocVersion as SpaceDocVersion2 } from "@dxos/echo-protocol";
+import { invariant as invariant11 } from "@dxos/invariant";
 
 // packages/core/echo/echo-pipeline/src/db-host/automerge-metrics.ts
 import * as A4 from "@automerge/automerge";
-import { log as log10 } from "@dxos/log";
-var __dxlog_file12 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/automerge-metrics.ts";
+import { log as log11 } from "@dxos/log";
+var __dxlog_file13 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/automerge-metrics.ts";
 var measureDocMetrics = (doc) => {
   const snapshot = A4.save(doc);
   const start = Date.now();
@@ -2865,10 +3659,10 @@ var measureDocMetrics = (doc) => {
   const mutationCount = A4.getAllChanges(doc).length;
   const getAllChangesEnd = Date.now();
   if (getAllChangesEnd - getAllChangesStart > 300) {
-    log10.warn("getAllChanges took too long", {
+    log11.warn("getAllChanges took too long", {
       elapsed: getAllChangesEnd - getAllChangesStart
     }, {
-      F: __dxlog_file12,
+      F: __dxlog_file13,
       L: 31,
       S: void 0,
       C: (f, a) => f(...a)
@@ -2882,7 +3676,7 @@ var measureDocMetrics = (doc) => {
 };
 
 // packages/core/echo/echo-pipeline/src/db-host/database-root.ts
-var __dxlog_file13 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/database-root.ts";
+var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/database-root.ts";
 var DatabaseRoot = class {
   static mapLinks(doc, mapping) {
     doc.change((d) => {
@@ -2927,7 +3721,7 @@ var DatabaseRoot = class {
     if (!doc) {
       return null;
     }
-    return getSpaceKeyFromDoc(doc);
+    return DatabaseDirectory5.getSpaceKey(doc);
   }
   getInlineObjectCount() {
     const doc = this.doc();
@@ -2945,9 +3739,9 @@ var DatabaseRoot = class {
   }
   getAllLinkedDocuments() {
     const doc = this.doc();
-    invariant10(doc, void 0, {
-      F: __dxlog_file13,
-      L: 89,
+    invariant11(doc, void 0, {
+      F: __dxlog_file14,
+      L: 88,
       S: this,
       A: [
         "doc",
@@ -2966,7 +3760,7 @@ var DatabaseRoot = class {
 };
 
 // packages/core/echo/echo-pipeline/src/db-host/space-state-manager.ts
-var __dxlog_file14 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/space-state-manager.ts";
+var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/space-state-manager.ts";
 var SpaceStateManager = class extends Resource8 {
   constructor() {
     super(...arguments);
@@ -2991,6 +3785,22 @@ var SpaceStateManager = class extends Resource8 {
   getSpaceRootDocumentId(spaceId) {
     return this._rootBySpace.get(spaceId);
   }
+  getRootBySpaceId(spaceId) {
+    invariant12(this._lifecycleState === LifecycleState4.OPEN, void 0, {
+      F: __dxlog_file15,
+      L: 44,
+      S: this,
+      A: [
+        "this._lifecycleState === LifecycleState.OPEN",
+        ""
+      ]
+    });
+    const documentId = this._rootBySpace.get(spaceId);
+    if (!documentId) {
+      return void 0;
+    }
+    return this._roots.get(documentId);
+  }
   async assignRootToSpace(spaceId, handle) {
     let root;
     if (this._roots.has(handle.documentId)) {
@@ -3009,8 +3819,8 @@ var SpaceStateManager = class extends Resource8 {
     }
     this._rootBySpace.set(spaceId, root.handle.documentId);
     const ctx = new Context5(void 0, {
-      F: __dxlog_file14,
-      L: 62
+      F: __dxlog_file15,
+      L: 72
     });
     this._perRootContext.set(root.handle.documentId, ctx);
     await root.handle.whenReady();
@@ -3043,19 +3853,20 @@ var SpaceDocumentListUpdatedEvent = class {
 };
 
 // packages/core/echo/echo-pipeline/src/db-host/echo-host.ts
-var __dxlog_file15 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/echo-host.ts";
-var INDEXER_CONFIG = {
-  enabled: true,
-  indexes: [
-    {
-      kind: IndexKind.Kind.SCHEMA_MATCH
-    }
-  ]
+var __dxlog_file16 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/echo-host.ts";
+var DEFAULT_INDEXING_CONFIG = {
+  // TODO(dmaretskyi): Disabled by default since embedding generation is expensive.
+  fullText: false,
+  vector: false
 };
 var EchoHost = class extends Resource9 {
-  constructor({ kv, peerIdProvider, getSpaceKeyByRootDocumentId }) {
+  constructor({ kv, indexing = {}, peerIdProvider, getSpaceKeyByRootDocumentId }) {
     super();
     this._spaceStateManager = new SpaceStateManager();
+    const indexingConfig = {
+      ...DEFAULT_INDEXING_CONFIG,
+      ...indexing
+    };
     this._indexMetadataStore = new IndexMetadataStore({
       db: kv.sublevel("index-metadata")
     });
@@ -3076,10 +3887,32 @@ var EchoHost = class extends Resource9 {
       loadDocuments: createSelectedDocumentsIterator(this._automergeHost),
       indexCooldownTime: false ? 0 : void 0
     });
-    void this._indexer.setConfig(INDEXER_CONFIG);
+    void this._indexer.setConfig({
+      enabled: true,
+      indexes: [
+        //
+        {
+          kind: IndexKind.Kind.SCHEMA_MATCH
+        },
+        {
+          kind: IndexKind.Kind.GRAPH
+        },
+        ...indexingConfig.fullText ? [
+          {
+            kind: IndexKind.Kind.FULL_TEXT
+          }
+        ] : [],
+        ...indexingConfig.vector ? [
+          {
+            kind: IndexKind.Kind.VECTOR
+          }
+        ] : []
+      ]
+    });
     this._queryService = new QueryServiceImpl({
       automergeHost: this._automergeHost,
-      indexer: this._indexer
+      indexer: this._indexer,
+      spaceStateManager: this._spaceStateManager
     });
     this._dataService = new DataServiceImpl({
       automergeHost: this._automergeHost,
@@ -3088,7 +3921,7 @@ var EchoHost = class extends Resource9 {
         await this._indexer.updateIndexes();
       }
     });
-    trace6.diagnostic({
+    trace5.diagnostic({
       id: "echo-stats",
       name: "Echo Stats",
       fetch: async () => {
@@ -3098,7 +3931,7 @@ var EchoHost = class extends Resource9 {
         };
       }
     });
-    trace6.diagnostic({
+    trace5.diagnostic({
       id: "database-roots",
       name: "Database Roots",
       fetch: async () => {
@@ -3111,7 +3944,7 @@ var EchoHost = class extends Resource9 {
         }));
       }
     });
-    trace6.diagnostic({
+    trace5.diagnostic({
       id: "database-root-metrics",
       name: "Database Roots (with metrics)",
       fetch: async () => {
@@ -3155,8 +3988,8 @@ var EchoHost = class extends Resource9 {
     });
   }
   async _close(ctx) {
-    await this._spaceStateManager.close();
     await this._queryService.close(ctx);
+    await this._spaceStateManager.close(ctx);
     await this._indexer.close(ctx);
     await this._automergeHost.close();
   }
@@ -3191,16 +4024,16 @@ var EchoHost = class extends Resource9 {
   * Create new space root.
   */
   async createSpaceRoot(spaceKey) {
-    invariant11(this._lifecycleState === LifecycleState4.OPEN, void 0, {
-      F: __dxlog_file15,
-      L: 226,
+    invariant13(this._lifecycleState === LifecycleState5.OPEN, void 0, {
+      F: __dxlog_file16,
+      L: 252,
       S: this,
       A: [
         "this._lifecycleState === LifecycleState.OPEN",
         ""
       ]
     });
-    const spaceId = await createIdFromSpaceKey3(spaceKey);
+    const spaceId = await createIdFromSpaceKey2(spaceKey);
     const automergeRoot = this._automergeHost.createDoc({
       version: SpaceDocVersion3.CURRENT,
       access: {
@@ -3219,9 +4052,9 @@ var EchoHost = class extends Resource9 {
   }
   // TODO(dmaretskyi): Change to document id.
   async openSpaceRoot(spaceId, automergeUrl) {
-    invariant11(this._lifecycleState === LifecycleState4.OPEN, void 0, {
-      F: __dxlog_file15,
-      L: 245,
+    invariant13(this._lifecycleState === LifecycleState5.OPEN, void 0, {
+      F: __dxlog_file16,
+      L: 271,
       S: this,
       A: [
         "this._lifecycleState === LifecycleState.OPEN",
@@ -3255,8 +4088,8 @@ import { cbor as cbor2 } from "@automerge/automerge-repo";
 import { Mutex, scheduleTask as scheduleTask2, scheduleMicroTask } from "@dxos/async";
 import { Context as Context6, Resource as Resource11 } from "@dxos/context";
 import { randomUUID } from "@dxos/crypto";
-import { invariant as invariant12 } from "@dxos/invariant";
-import { log as log12 } from "@dxos/log";
+import { invariant as invariant14 } from "@dxos/invariant";
+import { log as log13 } from "@dxos/log";
 import { EdgeService } from "@dxos/protocols";
 import { buf } from "@dxos/protocols/buf";
 import { MessageSchema as RouterMessageSchema } from "@dxos/protocols/buf/dxos/edge/messenger_pb";
@@ -3265,14 +4098,11 @@ import { bufferToArray as bufferToArray2 } from "@dxos/util";
 // packages/core/echo/echo-pipeline/src/edge/inflight-request-limiter.ts
 import { Trigger as Trigger2 } from "@dxos/async";
 import { Resource as Resource10 } from "@dxos/context";
-import { log as log11 } from "@dxos/log";
-var __dxlog_file16 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/edge/inflight-request-limiter.ts";
+import { log as log12 } from "@dxos/log";
+var __dxlog_file17 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/edge/inflight-request-limiter.ts";
 var InflightRequestLimiter = class extends Resource10 {
   constructor(_config) {
-    super();
-    this._config = _config;
-    this._inflightRequestBalance = 0;
-    this._requestBarrier = new Trigger2();
+    super(), this._config = _config, this._inflightRequestBalance = 0, this._requestBarrier = new Trigger2();
   }
   async _open() {
     this._inflightRequestBalance = 0;
@@ -3295,8 +4125,8 @@ var InflightRequestLimiter = class extends Resource10 {
     if (this._inflightRequestBalance === this._config.maxInflightRequests) {
       this._requestBarrier.reset();
       this._resetBalanceTimeout = setTimeout(() => {
-        log11.warn("Request balance has not changed during specified timeout, resetting request limiter.", void 0, {
-          F: __dxlog_file16,
+        log12.warn("Request balance has not changed during specified timeout, resetting request limiter.", void 0, {
+          F: __dxlog_file17,
           L: 52,
           S: this,
           C: (f, a) => f(...a)
@@ -3319,69 +4149,72 @@ var InflightRequestLimiter = class extends Resource10 {
 };
 
 // packages/core/echo/echo-pipeline/src/edge/echo-edge-replicator.ts
-function _using_ctx() {
-  var _disposeSuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed) {
-    var err = new Error();
-    err.name = "SuppressedError";
-    err.suppressed = suppressed;
-    err.error = error;
-    return err;
-  }, empty = {}, stack = [];
-  function using(isAwait, value) {
-    if (value != null) {
-      if (Object(value) !== value) {
-        throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
-      }
-      if (isAwait) {
-        var dispose = value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
-      }
-      if (dispose == null) {
-        dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
-      }
-      if (typeof dispose !== "function") {
-        throw new TypeError(`Property [Symbol.dispose] is not a function.`);
-      }
-      stack.push({
-        v: value,
-        d: dispose,
-        a: isAwait
-      });
-    } else if (isAwait) {
-      stack.push({
-        d: value,
-        a: isAwait
-      });
+function _ts_add_disposable_resource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
     }
-    return value;
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
   }
-  return {
-    e: empty,
-    u: using.bind(null, false),
-    a: using.bind(null, true),
-    d: function() {
-      var error = this.e;
-      function next() {
-        while (resource = stack.pop()) {
-          try {
-            var resource, disposalResult = resource.d && resource.d.call(resource.v);
-            if (resource.a) {
-              return Promise.resolve(disposalResult).then(next, err);
-            }
-          } catch (e) {
-            return err(e);
-          }
+  return value;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
         }
-        if (error !== empty) throw error;
       }
-      function err(e) {
-        error = error !== empty ? new _disposeSuppressedError(error, e) : e;
-        return next();
-      }
-      return next();
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
     }
-  };
+    return next();
+  })(env);
 }
-var __dxlog_file17 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/edge/echo-edge-replicator.ts";
+var __dxlog_file18 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/edge/echo-edge-replicator.ts";
 var INITIAL_RESTART_DELAY = 500;
 var RESTART_DELAY_JITTER = 250;
 var MAX_RESTART_DELAY = 5e3;
@@ -3397,18 +4230,18 @@ var EchoEdgeReplicator = class {
     this._sharePolicyEnabled = !disableSharePolicy;
   }
   async connect(context) {
-    log12.info("connecting...", {
+    log13.info("connecting...", {
       peerId: context.peerId,
       connectedSpaces: this._connectedSpaces.size
     }, {
-      F: __dxlog_file17,
+      F: __dxlog_file18,
       L: 61,
       S: this,
       C: (f, a) => f(...a)
     });
     this._context = context;
     this._ctx = Context6.default(void 0, {
-      F: __dxlog_file17,
+      F: __dxlog_file18,
       L: 64
     });
     this._ctx.onDispose(this._edgeConnection.onReconnected(() => {
@@ -3416,9 +4249,13 @@ var EchoEdgeReplicator = class {
     }));
   }
   async _handleReconnect() {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
     try {
-      var _usingCtx = _using_ctx();
-      const _guard = _usingCtx.u(await this._mutex.acquire());
+      const _guard = _ts_add_disposable_resource(env, await this._mutex.acquire(), false);
       const spaces = [
         ...this._connectedSpaces
       ];
@@ -3431,31 +4268,41 @@ var EchoEdgeReplicator = class {
           await this._openConnection(spaceId);
         }
       }
-    } catch (_) {
-      _usingCtx.e = _;
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
     } finally {
-      _usingCtx.d();
+      _ts_dispose_resources(env);
     }
   }
   async disconnect() {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
     try {
-      var _usingCtx = _using_ctx();
-      const _guard = _usingCtx.u(await this._mutex.acquire());
+      const _guard = _ts_add_disposable_resource(env, await this._mutex.acquire(), false);
       await this._ctx?.dispose();
       for (const connection of this._connections.values()) {
         await connection.close();
       }
       this._connections.clear();
-    } catch (_) {
-      _usingCtx.e = _;
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
     } finally {
-      _usingCtx.d();
+      _ts_dispose_resources(env);
     }
   }
   async connectToSpace(spaceId) {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
     try {
-      var _usingCtx = _using_ctx();
-      const _guard = _usingCtx.u(await this._mutex.acquire());
+      const _guard = _ts_add_disposable_resource(env, await this._mutex.acquire(), false);
       if (this._connectedSpaces.has(spaceId)) {
         return;
       }
@@ -3463,31 +4310,37 @@ var EchoEdgeReplicator = class {
       if (this._context !== null) {
         await this._openConnection(spaceId);
       }
-    } catch (_) {
-      _usingCtx.e = _;
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
     } finally {
-      _usingCtx.d();
+      _ts_dispose_resources(env);
     }
   }
   async disconnectFromSpace(spaceId) {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
     try {
-      var _usingCtx = _using_ctx();
-      const _guard = _usingCtx.u(await this._mutex.acquire());
+      const _guard = _ts_add_disposable_resource(env, await this._mutex.acquire(), false);
       this._connectedSpaces.delete(spaceId);
       const connection = this._connections.get(spaceId);
       if (connection) {
         await connection.close();
         this._connections.delete(spaceId);
       }
-    } catch (_) {
-      _usingCtx.e = _;
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
     } finally {
-      _usingCtx.d();
+      _ts_dispose_resources(env);
     }
   }
   async _openConnection(spaceId, reconnects = 0) {
-    invariant12(this._context, void 0, {
-      F: __dxlog_file17,
+    invariant14(this._context, void 0, {
+      F: __dxlog_file18,
       L: 125,
       S: this,
       A: [
@@ -3495,8 +4348,8 @@ var EchoEdgeReplicator = class {
         ""
       ]
     });
-    invariant12(!this._connections.has(spaceId), void 0, {
-      F: __dxlog_file17,
+    invariant14(!this._connections.has(spaceId), void 0, {
+      F: __dxlog_file18,
       L: 126,
       S: this,
       A: [
@@ -3521,21 +4374,25 @@ var EchoEdgeReplicator = class {
           return;
         }
         const restartDelay = Math.min(MAX_RESTART_DELAY, INITIAL_RESTART_DELAY * reconnects) + Math.random() * RESTART_DELAY_JITTER;
-        log12.info("connection restart scheduled", {
+        log13.info("connection restart scheduled", {
           spaceId,
           reconnects,
           restartDelay
         }, {
-          F: __dxlog_file17,
+          F: __dxlog_file18,
           L: 149,
           S: this,
           C: (f, a) => f(...a)
         });
         restartScheduled = true;
         scheduleTask2(this._ctx, async () => {
+          const env = {
+            stack: [],
+            error: void 0,
+            hasError: false
+          };
           try {
-            var _usingCtx = _using_ctx();
-            const _guard = _usingCtx.u(await this._mutex.acquire());
+            const _guard = _ts_add_disposable_resource(env, await this._mutex.acquire(), false);
             if (this._connections.get(spaceId) !== connection) {
               return;
             }
@@ -3546,10 +4403,11 @@ var EchoEdgeReplicator = class {
               return;
             }
             await this._openConnection(spaceId, reconnects + 1);
-          } catch (_) {
-            _usingCtx.e = _;
+          } catch (e) {
+            env.error = e;
+            env.hasError = true;
           } finally {
-            _usingCtx.d();
+            _ts_dispose_resources(env);
           }
         }, restartDelay);
       }
@@ -3590,8 +4448,8 @@ var EdgeReplicatorConnection = class extends Resource11 {
     });
   }
   async _open(ctx) {
-    log12("opening...", void 0, {
-      F: __dxlog_file17,
+    log13("opening...", void 0, {
+      F: __dxlog_file18,
       L: 252,
       S: this,
       C: (f, a) => f(...a)
@@ -3603,8 +4461,8 @@ var EdgeReplicatorConnection = class extends Resource11 {
     await this._onRemoteConnected();
   }
   async _close() {
-    log12("closing...", void 0, {
-      F: __dxlog_file17,
+    log13("closing...", void 0, {
+      F: __dxlog_file18,
       L: 267,
       S: this,
       C: (f, a) => f(...a)
@@ -3614,8 +4472,8 @@ var EdgeReplicatorConnection = class extends Resource11 {
     await this._onRemoteDisconnected();
   }
   get peerId() {
-    invariant12(this._remotePeerId, "Not connected", {
-      F: __dxlog_file17,
+    invariant14(this._remotePeerId, "Not connected", {
+      F: __dxlog_file18,
       L: 276,
       S: this,
       A: [
@@ -3635,12 +4493,12 @@ var EdgeReplicatorConnection = class extends Resource11 {
         documentId: params.documentId,
         peerId: this._remotePeerId
       });
-      log12.verbose("document not found locally for share policy check", {
+      log13.verbose("document not found locally for share policy check", {
         documentId: params.documentId,
         acceptDocument: remoteDocumentExists,
         remoteId: this._remotePeerId
       }, {
-        F: __dxlog_file17,
+        F: __dxlog_file18,
         L: 291,
         S: this,
         C: (f, a) => f(...a)
@@ -3661,12 +4519,12 @@ var EdgeReplicatorConnection = class extends Resource11 {
       return;
     }
     const payload = cbor2.decode(message.payload.value);
-    log12.verbose("received", {
+    log13.verbose("received", {
       type: payload.type,
       documentId: payload.type === "sync" && payload.documentId,
       remoteId: this._remotePeerId
     }, {
-      F: __dxlog_file17,
+      F: __dxlog_file18,
       L: 320,
       S: this,
       C: (f, a) => f(...a)
@@ -3684,12 +4542,12 @@ var EdgeReplicatorConnection = class extends Resource11 {
   }
   async _sendMessage(message) {
     message.targetId = this._targetServiceId;
-    log12.verbose("sending...", {
+    log13.verbose("sending...", {
       type: message.type,
       documentId: message.type === "sync" && message.documentId,
       remoteId: this._remotePeerId
     }, {
-      F: __dxlog_file17,
+      F: __dxlog_file18,
       L: 349,
       S: this,
       C: (f, a) => f(...a)
@@ -3710,11 +4568,12 @@ var EdgeReplicatorConnection = class extends Resource11 {
 var isForbiddenErrorMessage = (message) => message.type === "error" && message.message === "Forbidden";
 
 // packages/core/echo/echo-pipeline/src/util.ts
-import { decodeReference } from "@dxos/echo-protocol";
+import { decodeReference, ObjectStructure as ObjectStructure2 } from "@dxos/echo-protocol";
 var findInlineObjectOfType = (spaceDoc, typename) => {
   for (const id in spaceDoc.objects ?? {}) {
     const obj = spaceDoc.objects[id];
-    if (obj.system.type && decodeReference(obj.system.type).objectId === typename) {
+    const objType = ObjectStructure2.getTypeReference(obj);
+    if (objType && decodeReference(objType).objectId === typename) {
       return [
         id,
         obj
@@ -3735,6 +4594,7 @@ export {
   EchoDataMonitor,
   EchoEdgeReplicator,
   EchoHost,
+  ExecutionTrace,
   FIND_PARAMS,
   LevelDBStorageAdapter,
   MOCK_AUTH_PROVIDER,
@@ -3742,8 +4602,10 @@ export {
   MeshEchoReplicator,
   MetadataStore,
   Pipeline,
+  QueryExecutor,
+  QueryPlan,
+  QueryPlanner,
   QueryServiceImpl,
-  QueryState,
   Space,
   SpaceDocumentListUpdatedEvent,
   SpaceManager,
@@ -3757,9 +4619,10 @@ export {
   deriveCollectionIdFromSpaceId,
   diffCollectionState,
   encodingOptions,
+  filterMatchObject,
+  filterMatchValue,
   findInlineObjectOfType,
   getSpaceIdFromCollectionId,
-  getSpaceKeyFromDoc,
   hasInvitationExpired,
   mapFeedIndexesToTimeframe,
   mapTimeframeToFeedIndexes,