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

package/dist/lib/node/index.cjs

@@ -28,50 +28,56 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  AuthExtension: () => import_chunk_QD3U65NM.AuthExtension,
-  AuthStatus: () => import_chunk_QD3U65NM.AuthStatus,
+  AuthExtension: () => import_chunk_SG2PL5RH.AuthExtension,
+  AuthStatus: () => import_chunk_SG2PL5RH.AuthStatus,
   AutomergeHost: () => AutomergeHost,
-  CredentialRetrieverExtension: () => import_chunk_QD3U65NM.CredentialRetrieverExtension,
-  CredentialServerExtension: () => import_chunk_QD3U65NM.CredentialServerExtension,
+  CredentialRetrieverExtension: () => import_chunk_SG2PL5RH.CredentialRetrieverExtension,
+  CredentialServerExtension: () => import_chunk_SG2PL5RH.CredentialServerExtension,
   DataServiceImpl: () => DataServiceImpl,
   DatabaseRoot: () => DatabaseRoot,
   DocumentsSynchronizer: () => DocumentsSynchronizer,
   EchoDataMonitor: () => EchoDataMonitor,
   EchoEdgeReplicator: () => EchoEdgeReplicator,
   EchoHost: () => EchoHost,
+  ExecutionTrace: () => ExecutionTrace,
   FIND_PARAMS: () => FIND_PARAMS,
   LevelDBStorageAdapter: () => LevelDBStorageAdapter,
-  MOCK_AUTH_PROVIDER: () => import_chunk_QD3U65NM.MOCK_AUTH_PROVIDER,
-  MOCK_AUTH_VERIFIER: () => import_chunk_QD3U65NM.MOCK_AUTH_VERIFIER,
+  MOCK_AUTH_PROVIDER: () => import_chunk_SG2PL5RH.MOCK_AUTH_PROVIDER,
+  MOCK_AUTH_VERIFIER: () => import_chunk_SG2PL5RH.MOCK_AUTH_VERIFIER,
   MeshEchoReplicator: () => MeshEchoReplicator,
-  MetadataStore: () => import_chunk_QD3U65NM.MetadataStore,
-  Pipeline: () => import_chunk_QD3U65NM.Pipeline,
+  MetadataStore: () => import_chunk_SG2PL5RH.MetadataStore,
+  Pipeline: () => import_chunk_SG2PL5RH.Pipeline,
+  QueryExecutor: () => QueryExecutor,
+  QueryPlan: () => QueryPlan,
+  QueryPlanner: () => QueryPlanner,
   QueryServiceImpl: () => QueryServiceImpl,
-  QueryState: () => QueryState,
-  Space: () => import_chunk_QD3U65NM.Space,
+  Space: () => import_chunk_SG2PL5RH.Space,
   SpaceDocumentListUpdatedEvent: () => SpaceDocumentListUpdatedEvent,
-  SpaceManager: () => import_chunk_QD3U65NM.SpaceManager,
-  SpaceProtocol: () => import_chunk_QD3U65NM.SpaceProtocol,
-  SpaceProtocolSession: () => import_chunk_QD3U65NM.SpaceProtocolSession,
+  SpaceManager: () => import_chunk_SG2PL5RH.SpaceManager,
+  SpaceProtocol: () => import_chunk_SG2PL5RH.SpaceProtocol,
+  SpaceProtocolSession: () => import_chunk_SG2PL5RH.SpaceProtocolSession,
   SpaceStateManager: () => SpaceStateManager,
-  TimeframeClock: () => import_chunk_QD3U65NM.TimeframeClock,
-  codec: () => import_chunk_QD3U65NM.codec,
-  createIdFromSpaceKey: () => import_chunk_QD3U65NM.createIdFromSpaceKey,
-  createMappedFeedWriter: () => import_chunk_QD3U65NM.createMappedFeedWriter,
+  TimeframeClock: () => import_chunk_SG2PL5RH.TimeframeClock,
+  codec: () => import_chunk_SG2PL5RH.codec,
+  createIdFromSpaceKey: () => import_chunk_SG2PL5RH.createIdFromSpaceKey,
+  createMappedFeedWriter: () => import_chunk_SG2PL5RH.createMappedFeedWriter,
   deriveCollectionIdFromSpaceId: () => deriveCollectionIdFromSpaceId,
   diffCollectionState: () => diffCollectionState,
   encodingOptions: () => encodingOptions,
+  filterMatchObject: () => import_chunk_HOPOFWAL.filterMatchObject,
+  filterMatchValue: () => import_chunk_HOPOFWAL.filterMatchValue,
   findInlineObjectOfType: () => findInlineObjectOfType,
   getSpaceIdFromCollectionId: () => getSpaceIdFromCollectionId,
-  getSpaceKeyFromDoc: () => getSpaceKeyFromDoc,
-  hasInvitationExpired: () => import_chunk_QD3U65NM.hasInvitationExpired,
-  mapFeedIndexesToTimeframe: () => import_chunk_QD3U65NM.mapFeedIndexesToTimeframe,
-  mapTimeframeToFeedIndexes: () => import_chunk_QD3U65NM.mapTimeframeToFeedIndexes,
-  startAfter: () => import_chunk_QD3U65NM.startAfter,
-  valueEncoding: () => import_chunk_QD3U65NM.valueEncoding
+  hasInvitationExpired: () => import_chunk_SG2PL5RH.hasInvitationExpired,
+  mapFeedIndexesToTimeframe: () => import_chunk_SG2PL5RH.mapFeedIndexesToTimeframe,
+  mapTimeframeToFeedIndexes: () => import_chunk_SG2PL5RH.mapTimeframeToFeedIndexes,
+  startAfter: () => import_chunk_SG2PL5RH.startAfter,
+  valueEncoding: () => import_chunk_SG2PL5RH.valueEncoding
 });
 module.exports = __toCommonJS(node_exports);
-var import_chunk_QD3U65NM = require("./chunk-QD3U65NM.cjs");
+var import_chunk_HOPOFWAL = require("./chunk-HOPOFWAL.cjs");
+var import_chunk_SG2PL5RH = require("./chunk-SG2PL5RH.cjs");
+var import_chunk_Q7SFCCGT = require("./chunk-Q7SFCCGT.cjs");
 var import_async = require("@dxos/async");
 var import_stream = require("@dxos/codec-protobuf/stream");
 var import_invariant = require("@dxos/invariant");
@@ -86,6 +92,7 @@ var import_automerge2 = require("@automerge/automerge");
 var import_automerge_repo = require("@automerge/automerge-repo");
 var import_async3 = require("@dxos/async");
 var import_context2 = require("@dxos/context");
+var import_echo_protocol = require("@dxos/echo-protocol");
 var import_invariant3 = require("@dxos/invariant");
 var import_keys2 = require("@dxos/keys");
 var import_log3 = require("@dxos/log");
@@ -123,63 +130,67 @@ var import_tracing3 = require("@dxos/tracing");
 var import_util5 = require("@dxos/util");
 var import_context7 = require("@dxos/context");
 var import_debug = require("@dxos/debug");
-var import_echo_protocol = require("@dxos/echo-protocol");
+var import_echo_protocol2 = require("@dxos/echo-protocol");
 var import_indexing2 = require("@dxos/indexing");
 var import_invariant8 = require("@dxos/invariant");
 var import_indexing3 = require("@dxos/protocols/proto/dxos/echo/indexing");
 var import_tracing4 = require("@dxos/tracing");
 var A3 = __toESM(require("@automerge/automerge"));
 var import_context8 = require("@dxos/context");
-var import_echo_protocol2 = require("@dxos/echo-protocol");
+var import_echo_protocol3 = require("@dxos/echo-protocol");
 var import_invariant9 = require("@dxos/invariant");
 var import_log8 = require("@dxos/log");
 var import_protocols3 = require("@dxos/protocols");
 var import_automerge4 = require("@automerge/automerge");
+var import_effect = require("effect");
 var import_async6 = require("@dxos/async");
 var import_stream2 = require("@dxos/codec-protobuf/stream");
 var import_context9 = require("@dxos/context");
+var import_debug2 = require("@dxos/debug");
+var import_echo_protocol4 = require("@dxos/echo-protocol");
 var import_log9 = require("@dxos/log");
 var import_protocols4 = require("@dxos/protocols");
 var import_tracing5 = require("@dxos/tracing");
+var import_effect2 = require("effect");
 var import_context10 = require("@dxos/context");
-var import_echo_protocol3 = require("@dxos/echo-protocol");
+var import_echo_protocol5 = require("@dxos/echo-protocol");
+var import_indexing4 = require("@dxos/indexing");
 var import_invariant10 = require("@dxos/invariant");
 var import_keys5 = require("@dxos/keys");
+var import_log10 = require("@dxos/log");
 var import_protocols5 = require("@dxos/protocols");
-var import_tracing6 = require("@dxos/tracing");
 var import_util6 = require("@dxos/util");
+var import_invariant11 = require("@dxos/invariant");
+var import_errors = require("@dxos/errors");
 var import_automerge_repo4 = require("@automerge/automerge-repo");
 var import_lodash = __toESM(require("lodash.isequal"));
 var import_async7 = require("@dxos/async");
 var import_context11 = require("@dxos/context");
+var import_invariant12 = require("@dxos/invariant");
 var import_automerge_repo5 = require("@automerge/automerge-repo");
-var import_echo_protocol4 = require("@dxos/echo-protocol");
-var import_invariant11 = require("@dxos/invariant");
+var import_echo_protocol6 = require("@dxos/echo-protocol");
+var import_invariant13 = require("@dxos/invariant");
 var A4 = __toESM(require("@automerge/automerge"));
-var import_log10 = require("@dxos/log");
+var import_log11 = require("@dxos/log");
 var import_automerge_repo6 = require("@automerge/automerge-repo");
 var import_async8 = require("@dxos/async");
 var import_context12 = require("@dxos/context");
 var import_crypto = require("@dxos/crypto");
-var import_invariant12 = require("@dxos/invariant");
-var import_log11 = require("@dxos/log");
+var import_invariant14 = require("@dxos/invariant");
+var import_log12 = require("@dxos/log");
 var import_protocols6 = require("@dxos/protocols");
 var import_buf = require("@dxos/protocols/buf");
 var import_messenger_pb = require("@dxos/protocols/buf/dxos/edge/messenger_pb");
 var import_util7 = require("@dxos/util");
 var import_async9 = require("@dxos/async");
 var import_context13 = require("@dxos/context");
-var import_log12 = require("@dxos/log");
-var import_echo_protocol5 = require("@dxos/echo-protocol");
+var import_log13 = require("@dxos/log");
+var import_echo_protocol7 = require("@dxos/echo-protocol");
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/documents-synchronizer.ts";
 var MAX_UPDATE_FREQ = 10;
 var DocumentsSynchronizer = class extends import_context.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) {
@@ -583,13 +594,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 import_automerge_repo2.NetworkAdapter {
   constructor(_params) {
-    super();
-    this._params = _params;
-    this._replicators = /* @__PURE__ */ new Set();
-    this._connections = /* @__PURE__ */ new Map();
-    this._lifecycleState = import_context4.LifecycleState.CLOSED;
-    this._connected = new import_async5.Trigger();
-    this._ready = new import_async5.Trigger();
+    super(), this._params = _params, this._replicators = /* @__PURE__ */ new Set(), this._connections = /* @__PURE__ */ new Map(), this._lifecycleState = import_context4.LifecycleState.CLOSED, this._connected = new import_async5.Trigger(), this._ready = new import_async5.Trigger();
   }
   isReady() {
     return this._lifecycleState === import_context4.LifecycleState.OPEN;
@@ -668,7 +673,7 @@ var EchoNetworkAdapter = class extends import_automerge_repo2.NetworkAdapter {
       getContainingSpaceForDocument: this._params.getContainingSpaceForDocument,
       getContainingSpaceIdForDocument: async (documentId) => {
         const key = await this._params.getContainingSpaceForDocument(documentId);
-        return key ? (0, import_chunk_QD3U65NM.createIdFromSpaceKey)(key) : null;
+        return key ? (0, import_chunk_SG2PL5RH.createIdFromSpaceKey)(key) : null;
       }
     });
   }
@@ -941,8 +946,7 @@ var HeadsStore = class {
 };
 var LevelDBStorageAdapter = class extends import_context5.Resource {
   constructor(_params) {
-    super();
-    this._params = _params;
+    super(), this._params = _params;
   }
   async load(keyArray) {
     try {
@@ -1281,7 +1285,7 @@ var AutomergeHost = class extends import_context2.Resource {
     }
     const heads = (0, import_automerge2.getHeads)(doc);
     this._headsStore.setHeads(handle.documentId, heads, batch);
-    const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+    const spaceKey = import_echo_protocol.DatabaseDirectory.getSpaceKey(doc) ?? void 0;
     const objectIds = Object.keys(doc.objects ?? {});
     const encodedIds = objectIds.map((objectId) => import_protocols.objectPointerCodec.encode({
       documentId: handle.documentId,
@@ -1334,7 +1338,7 @@ var AutomergeHost = class extends import_context2.Resource {
       await handle.whenReady();
     }
     if (handle && handle.isReady() && handle.doc()) {
-      const spaceKeyHex = getSpaceKeyFromDoc(handle.doc());
+      const spaceKeyHex = import_echo_protocol.DatabaseDirectory.getSpaceKey(handle.doc());
       if (spaceKeyHex) {
         return import_keys2.PublicKey.from(spaceKeyHex);
       }
@@ -1349,7 +1353,10 @@ var AutomergeHost = class extends import_context2.Resource {
   * 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) {
@@ -1464,7 +1471,7 @@ var AutomergeHost = class extends import_context2.Resource {
       count: toReplicate.length
     }, {
       F: __dxlog_file4,
-      L: 556,
+      L: 557,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -1506,13 +1513,6 @@ _ts_decorate3([
 AutomergeHost = _ts_decorate3([
   import_tracing.trace.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();
@@ -1531,7 +1531,7 @@ var changeIsPresentInDoc = (doc, changeHash) => {
 var decodeCollectionState = (state) => {
   (0, import_invariant3.invariant)(typeof state === "object" && state !== null, "Invalid state", {
     F: __dxlog_file4,
-    L: 617,
+    L: 608,
     S: void 0,
     A: [
       "typeof state === 'object' && state !== null",
@@ -1547,11 +1547,7 @@ var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipelin
 var DEFAULT_FACTORY = (params) => new import_teleport_extension_automerge_replicator.AutomergeReplicator(...params);
 var MeshReplicatorConnection = class extends import_context6.Resource {
   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) => {
@@ -1838,7 +1834,7 @@ var MeshEchoReplicator = class {
             });
             return remoteDocumentExists;
           }
-          const spaceId = await (0, import_chunk_QD3U65NM.createIdFromSpaceKey)(spaceKey);
+          const spaceId = await (0, import_chunk_SG2PL5RH.createIdFromSpaceKey)(spaceKey);
           const authorizedDevices = this._authorizedDevices.get(spaceId);
           if (!connection.remoteDeviceKey) {
             (0, import_log6.log)("device key not found for share policy check", {
@@ -1909,7 +1905,7 @@ var MeshEchoReplicator = class {
       S: this,
       C: (f, a) => f(...a)
     });
-    const spaceId = await (0, import_chunk_QD3U65NM.createIdFromSpaceKey)(spaceKey);
+    const spaceId = await (0, import_chunk_SG2PL5RH.createIdFromSpaceKey)(spaceKey);
     (0, import_util4.defaultMap)(this._authorizedDevices, spaceId, () => new import_util4.ComplexSet(import_keys3.PublicKey.hash)).add(deviceKey);
     for (const connection of this._connections) {
       if (connection.isEnabled && connection.remoteDeviceKey && connection.remoteDeviceKey.equals(deviceKey)) {
@@ -2456,7 +2452,7 @@ var createSelectedDocumentsIterator = (automergeHost) => (
             });
           }
         }
-        if (doc.version !== import_echo_protocol2.SpaceDocVersion.CURRENT) {
+        if (doc.version !== import_echo_protocol3.SpaceDocVersion.CURRENT) {
           continue;
         }
         if (!doc.objects?.[objectId]) {
@@ -2464,7 +2460,7 @@ var createSelectedDocumentsIterator = (automergeHost) => (
         }
         let newId = id;
         if (import_protocols3.objectPointerCodec.getVersion(id) === import_protocols3.ObjectPointerVersion.V0) {
-          const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+          const spaceKey = import_echo_protocol3.DatabaseDirectory.getSpaceKey(doc) ?? void 0;
           newId = import_protocols3.objectPointerCodec.encode({
             documentId,
             objectId,
@@ -2493,192 +2489,992 @@ var createSelectedDocumentsIterator = (automergeHost) => (
     }
   }
 );
-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 import_context10.Resource {
-  get active() {
-    return this._lifecycleState === import_context10.LifecycleState.OPEN;
+var QueryError = class extends import_errors.BaseError.extend("QUERY_ERROR") {
+};
+(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;
+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) => {
+            (0, import_invariant11.invariant)(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 } = import_protocols5.objectPointerCodec.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(import_context10.Context.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 (0, import_echo_protocol3.createIdFromSpaceKey)(import_keys5.PublicKey.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: import_keys5.PublicKey.from(spaceKey),
-        rank: result.rank
-      };
-    }))).filter(import_util6.isNonNullable);
-    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);
+};
+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 import_context10.Resource {
+  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() {
+    (0, import_invariant10.invariant)(this._lifecycleState === import_context10.LifecycleState.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 import_context10.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(import_util6.isNonNullable).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(import_keys5.DXN.fromLocalObjectId(id), {
+          sourceSpaceId: step.spaces[0]
+        })));
+        trace6.documentLoadTime += performance.now() - beginLoad;
+        workingSet.push(...items.filter(import_util6.isNonNullable));
+        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(import_util6.isNonNullable).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: import_effect2.Match.type().pipe(import_effect2.Match.withReturnType(), import_effect2.Match.when("full-text", () => "text"), import_effect2.Match.when("vector", () => "vector"), import_effect2.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(import_util6.isNonNullable).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([
-  import_tracing6.trace.info({
-    depth: null
-  })
-], QueryState.prototype, "filter", void 0);
-_ts_decorate5([
-  import_tracing6.trace.info()
-], QueryState.prototype, "metrics", void 0);
-_ts_decorate5([
-  import_tracing6.trace.info()
-], QueryState.prototype, "active", null);
-_ts_decorate5([
-  import_tracing6.trace.span({
-    showInBrowserTimeline: true,
-    op: "db.query",
-    attributes: {
-      "db.system": "echo"
+  async _execFilterStep(step, workingSet) {
+    const result = workingSet.filter((item) => (0, import_chunk_HOPOFWAL.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) => import_echo_protocol5.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 = import_indexing4.EscapedPropPath.unescape(step.traversal.property);
+            const refs = workingSet.map((item) => {
+              const ref = (0, import_util6.getDeep)(item.doc.data, property);
+              if (!(0, import_echo_protocol5.isEncodedReference)(ref)) {
+                return null;
+              }
+              try {
+                return {
+                  ref: import_keys5.DXN.parse(ref["/"]),
+                  spaceId: item.spaceId
+                };
+              } catch {
+                import_log10.log.warn("Invalid reference", {
+                  ref: ref["/"]
+                }, {
+                  F: __dxlog_file11,
+                  L: 421,
+                  S: this,
+                  C: (f, a) => f(...a)
+                });
+                return null;
+              }
+            }).filter(import_util6.isNonNullable);
+            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(import_util6.isNonNullable));
+            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(import_util6.isNonNullable));
+            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" ? import_echo_protocol5.ObjectStructure.getRelationSource(item.doc) : import_echo_protocol5.ObjectStructure.getRelationTarget(item.doc);
+              if (!(0, import_echo_protocol5.isEncodedReference)(ref)) {
+                return null;
+              }
+              try {
+                return {
+                  ref: import_keys5.DXN.parse(ref["/"]),
+                  spaceId: item.spaceId
+                };
+              } catch {
+                import_log10.log.warn("Invalid reference", {
+                  ref: ref["/"]
+                }, {
+                  F: __dxlog_file11,
+                  L: 483,
+                  S: this,
+                  C: (f, a) => f(...a)
+                });
+                return null;
+              }
+            }).filter(import_util6.isNonNullable);
+            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(import_util6.isNonNullable));
+            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(import_util6.isNonNullable));
+            trace6.objectCount = newWorkingSet.length;
+            break;
+          }
+        }
+        break;
+      }
+      default:
+        throw new Error(`Unknown traversal type: ${step.traversal._tag}`);
     }
-  })
-], QueryState.prototype, "execQuery", null);
-QueryState = _ts_decorate5([
-  import_tracing6.trace.resource()
-], QueryState);
-var filterToIndexQuery = (filter) => {
-  const { type = [], or = [] } = filter;
-  (0, import_invariant10.invariant)(!(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.'"
-    ]
-  });
-  (0, import_invariant10.invariant)(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(import_keys5.DXN.parse(type2))) : or.flatMap((f) => (f.type ?? []).map((type2) => dxnToIndexerTypename(import_keys5.DXN.parse(type2))) ?? []).filter(import_util6.isNonNullable),
-      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 import_keys5.DXN.kind.TYPE:
-      return dxn.parts[0];
-    case import_keys5.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 } = import_protocols5.objectPointerCodec.decode(hit.id);
+    const handle = await this._automergeHost.loadDoc(import_context10.Context.default(void 0, {
+      F: __dxlog_file11,
+      L: 571
+    }), documentId);
+    const doc = handle.doc();
+    if (!doc) {
+      return null;
+    }
+    const spaceKey = spaceKeyInIndex ?? import_echo_protocol5.DatabaseDirectory.getSpaceKey(doc);
+    if (!spaceKey) {
+      return null;
+    }
+    const object = import_echo_protocol5.DatabaseDirectory.getInlineObject(doc, objectId);
+    if (!object) {
+      return null;
+    }
+    return {
+      objectId,
+      documentId,
+      spaceId: await (0, import_chunk_SG2PL5RH.createIdFromSpaceKey)(import_keys5.PublicKey.from(spaceKey)),
+      doc: object
+    };
+  }
+  async _loadFromDXN(dxn, { sourceSpaceId }) {
+    const echoDxn = dxn.asEchoDXN();
+    if (!echoDxn) {
+      import_log10.log.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) {
+      import_log10.log.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) {
+      import_log10.log.warn("no space state found for", {
+        spaceId
+      }, {
+        F: __dxlog_file11,
+        L: 611,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return null;
+    }
+    const inlineObject = import_echo_protocol5.DatabaseDirectory.getInlineObject(dbDirectory, echoDxn.echoId);
+    if (inlineObject) {
+      return {
+        objectId: echoDxn.echoId,
+        documentId: spaceRoot.documentId,
+        spaceId,
+        doc: inlineObject
+      };
+    }
+    const link = import_echo_protocol5.DatabaseDirectory.getLink(dbDirectory, echoDxn.echoId);
+    if (!link) {
+      return null;
+    }
+    const handle = await this._automergeHost.loadDoc(import_context10.Context.default(void 0, {
+      F: __dxlog_file11,
+      L: 630
+    }), link);
+    const doc = handle.doc();
+    if (!doc) {
+      return null;
+    }
+    const object = import_echo_protocol5.DatabaseDirectory.getInlineObject(doc, echoDxn.echoId);
+    if (!object) {
+      return null;
+    }
+    return {
+      objectId: echoDxn.echoId,
+      documentId: handle.documentId,
+      spaceId,
+      doc: object
+    };
   }
 };
-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 import_context9.Resource {
   // 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 import_async6.DeferredTask(this._ctx, async () => {
+    super(), this._params = _params, this._queries = /* @__PURE__ */ new Set(), this._updateQueries = new import_async6.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) {
           import_log9.log.catch(err, void 0, {
-            F: __dxlog_file11,
-            L: 53,
+            F: __dxlog_file12,
+            L: 57,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -2691,8 +3487,9 @@ var QueryServiceImpl = class extends import_context9.Resource {
       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)
           };
         });
       }
@@ -2705,24 +3502,19 @@ var QueryServiceImpl = class extends import_context9.Resource {
     await Promise.all(Array.from(this._queries).map((query) => query.close()));
   }
   async setConfig(config) {
-    if (this._params.indexer.initialized) {
-      import_log9.log.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 import_stream2.Stream(({ next, close, ctx }) => {
-      const query = {
-        state: new QueryState({
+      const parsedQuery = import_echo_protocol4.QueryAST.Query.pipe(import_effect.Schema.decodeUnknownSync)(JSON.parse(request.query));
+      const queryEntry = {
+        executor: new QueryExecutor({
           indexer: this._params.indexer,
           automergeHost: this._params.automergeHost,
-          request
+          queryId: request.queryId ?? (0, import_debug2.raise)(new Error("query id required")),
+          query: parsedQuery,
+          reactivity: request.reactivity,
+          spaceStateManager: this._params.spaceStateManager
         }),
         sendResults: (results) => {
           if (ctx.disposed) {
@@ -2735,28 +3527,21 @@ var QueryServiceImpl = class extends import_context9.Resource {
         },
         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) {
-          import_log9.log.catch(error, void 0, {
-            F: __dxlog_file11,
-            L: 124,
-            S: this,
-            C: (f, a) => f(...a)
-          });
+          close(error);
         }
       });
-      return query.close;
+      return queryEntry.close;
     });
   }
   /**
@@ -2764,8 +3549,8 @@ var QueryServiceImpl = class extends import_context9.Resource {
   */
   async reindex() {
     import_log9.log.info("Reindexing all documents...", void 0, {
-      F: __dxlog_file11,
-      L: 136,
+      F: __dxlog_file12,
+      L: 141,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -2779,8 +3564,8 @@ var QueryServiceImpl = class extends import_context9.Resource {
         import_log9.log.info("Collected documents...", {
           count: ids.size
         }, {
-          F: __dxlog_file11,
-          L: 144,
+          F: __dxlog_file12,
+          L: 149,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -2789,8 +3574,8 @@ var QueryServiceImpl = class extends import_context9.Resource {
     import_log9.log.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)
     });
@@ -2809,7 +3594,7 @@ var createDocumentsIterator = (automergeHost) => (
         return;
       }
       const doc = handle.doc();
-      const spaceKey = getSpaceKeyFromDoc(doc) ?? void 0;
+      const spaceKey = import_echo_protocol4.DatabaseDirectory.getSpaceKey(doc) ?? void 0;
       if (doc.objects) {
         yield Object.entries(doc.objects).map(([objectId, object]) => {
           return {
@@ -2830,8 +3615,8 @@ var createDocumentsIterator = (automergeHost) => (
             continue;
           }
           const linkHandle = await automergeHost.loadDoc(import_context9.Context.default(void 0, {
-            F: __dxlog_file11,
-            L: 190
+            F: __dxlog_file12,
+            L: 195
           }), urlString);
           for await (const result of getObjectsFromHandle(linkHandle)) {
             yield result;
@@ -2851,7 +3636,7 @@ var createDocumentsIterator = (automergeHost) => (
     }
   }
 );
-var __dxlog_file12 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/db-host/automerge-metrics.ts";
+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();
@@ -2862,10 +3647,10 @@ var measureDocMetrics = (doc) => {
   const mutationCount = A4.getAllChanges(doc).length;
   const getAllChangesEnd = Date.now();
   if (getAllChangesEnd - getAllChangesStart > 300) {
-    import_log10.log.warn("getAllChanges took too long", {
+    import_log11.log.warn("getAllChanges took too long", {
       elapsed: getAllChangesEnd - getAllChangesStart
     }, {
-      F: __dxlog_file12,
+      F: __dxlog_file13,
       L: 31,
       S: void 0,
       C: (f, a) => f(...a)
@@ -2877,7 +3662,7 @@ var measureDocMetrics = (doc) => {
     mutationCount
   };
 };
-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) => {
@@ -2915,14 +3700,14 @@ var DatabaseRoot = class {
     if (!doc) {
       return null;
     }
-    return doc.version ?? import_echo_protocol4.SpaceDocVersion.LEGACY;
+    return doc.version ?? import_echo_protocol6.SpaceDocVersion.LEGACY;
   }
   getSpaceKey() {
     const doc = this.doc();
     if (!doc) {
       return null;
     }
-    return getSpaceKeyFromDoc(doc);
+    return import_echo_protocol6.DatabaseDirectory.getSpaceKey(doc);
   }
   getInlineObjectCount() {
     const doc = this.doc();
@@ -2940,9 +3725,9 @@ var DatabaseRoot = class {
   }
   getAllLinkedDocuments() {
     const doc = this.doc();
-    (0, import_invariant11.invariant)(doc, void 0, {
-      F: __dxlog_file13,
-      L: 89,
+    (0, import_invariant13.invariant)(doc, void 0, {
+      F: __dxlog_file14,
+      L: 88,
       S: this,
       A: [
         "doc",
@@ -2959,7 +3744,7 @@ var DatabaseRoot = class {
     return measureDocMetrics(doc);
   }
 };
-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 import_context11.Resource {
   constructor() {
     super(...arguments);
@@ -2984,6 +3769,22 @@ var SpaceStateManager = class extends import_context11.Resource {
   getSpaceRootDocumentId(spaceId) {
     return this._rootBySpace.get(spaceId);
   }
+  getRootBySpaceId(spaceId) {
+    (0, import_invariant12.invariant)(this._lifecycleState === import_context11.LifecycleState.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)) {
@@ -3002,8 +3803,8 @@ var SpaceStateManager = class extends import_context11.Resource {
     }
     this._rootBySpace.set(spaceId, root.handle.documentId);
     const ctx = new import_context11.Context(void 0, {
-      F: __dxlog_file14,
-      L: 62
+      F: __dxlog_file15,
+      L: 72
     });
     this._perRootContext.set(root.handle.documentId, ctx);
     await root.handle.whenReady();
@@ -3034,19 +3835,20 @@ var SpaceDocumentListUpdatedEvent = class {
     this.documentIds = documentIds;
   }
 };
-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: import_indexing3.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 import_context7.Resource {
-  constructor({ kv, peerIdProvider, getSpaceKeyByRootDocumentId }) {
+  constructor({ kv, indexing = {}, peerIdProvider, getSpaceKeyByRootDocumentId }) {
     super();
     this._spaceStateManager = new SpaceStateManager();
+    const indexingConfig = {
+      ...DEFAULT_INDEXING_CONFIG,
+      ...indexing
+    };
     this._indexMetadataStore = new import_indexing2.IndexMetadataStore({
       db: kv.sublevel("index-metadata")
     });
@@ -3067,10 +3869,32 @@ var EchoHost = class extends import_context7.Resource {
       loadDocuments: createSelectedDocumentsIterator(this._automergeHost),
       indexCooldownTime: process.env.NODE_ENV === "test" ? 0 : void 0
     });
-    void this._indexer.setConfig(INDEXER_CONFIG);
+    void this._indexer.setConfig({
+      enabled: true,
+      indexes: [
+        //
+        {
+          kind: import_indexing3.IndexKind.Kind.SCHEMA_MATCH
+        },
+        {
+          kind: import_indexing3.IndexKind.Kind.GRAPH
+        },
+        ...indexingConfig.fullText ? [
+          {
+            kind: import_indexing3.IndexKind.Kind.FULL_TEXT
+          }
+        ] : [],
+        ...indexingConfig.vector ? [
+          {
+            kind: import_indexing3.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,
@@ -3146,8 +3970,8 @@ var EchoHost = class extends import_context7.Resource {
     });
   }
   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();
   }
@@ -3183,17 +4007,17 @@ var EchoHost = class extends import_context7.Resource {
   */
   async createSpaceRoot(spaceKey) {
     (0, import_invariant8.invariant)(this._lifecycleState === import_context7.LifecycleState.OPEN, void 0, {
-      F: __dxlog_file15,
-      L: 226,
+      F: __dxlog_file16,
+      L: 252,
       S: this,
       A: [
         "this._lifecycleState === LifecycleState.OPEN",
         ""
       ]
     });
-    const spaceId = await (0, import_echo_protocol.createIdFromSpaceKey)(spaceKey);
+    const spaceId = await (0, import_echo_protocol2.createIdFromSpaceKey)(spaceKey);
     const automergeRoot = this._automergeHost.createDoc({
-      version: import_echo_protocol.SpaceDocVersion.CURRENT,
+      version: import_echo_protocol2.SpaceDocVersion.CURRENT,
       access: {
         spaceKey: spaceKey.toHex()
       },
@@ -3211,8 +4035,8 @@ var EchoHost = class extends import_context7.Resource {
   // TODO(dmaretskyi): Change to document id.
   async openSpaceRoot(spaceId, automergeUrl) {
     (0, import_invariant8.invariant)(this._lifecycleState === import_context7.LifecycleState.OPEN, void 0, {
-      F: __dxlog_file15,
-      L: 245,
+      F: __dxlog_file16,
+      L: 271,
       S: this,
       A: [
         "this._lifecycleState === LifecycleState.OPEN",
@@ -3240,13 +4064,10 @@ var EchoHost = class extends import_context7.Resource {
     await this._automergeHost.removeReplicator(replicator);
   }
 };
-var __dxlog_file16 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/edge/inflight-request-limiter.ts";
+var __dxlog_file17 = "/home/runner/work/dxos/dxos/packages/core/echo/echo-pipeline/src/edge/inflight-request-limiter.ts";
 var InflightRequestLimiter = class extends import_context13.Resource {
   constructor(_config) {
-    super();
-    this._config = _config;
-    this._inflightRequestBalance = 0;
-    this._requestBarrier = new import_async9.Trigger();
+    super(), this._config = _config, this._inflightRequestBalance = 0, this._requestBarrier = new import_async9.Trigger();
   }
   async _open() {
     this._inflightRequestBalance = 0;
@@ -3269,8 +4090,8 @@ var InflightRequestLimiter = class extends import_context13.Resource {
     if (this._inflightRequestBalance === this._config.maxInflightRequests) {
       this._requestBarrier.reset();
       this._resetBalanceTimeout = setTimeout(() => {
-        import_log12.log.warn("Request balance has not changed during specified timeout, resetting request limiter.", void 0, {
-          F: __dxlog_file16,
+        import_log13.log.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)
@@ -3291,69 +4112,72 @@ var InflightRequestLimiter = class extends import_context13.Resource {
     }
   }
 };
-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;
@@ -3369,18 +4193,18 @@ var EchoEdgeReplicator = class {
     this._sharePolicyEnabled = !disableSharePolicy;
   }
   async connect(context) {
-    import_log11.log.info("connecting...", {
+    import_log12.log.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 = import_context12.Context.default(void 0, {
-      F: __dxlog_file17,
+      F: __dxlog_file18,
       L: 64
     });
     this._ctx.onDispose(this._edgeConnection.onReconnected(() => {
@@ -3388,9 +4212,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
       ];
@@ -3403,31 +4231,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;
       }
@@ -3435,31 +4273,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) {
-    (0, import_invariant12.invariant)(this._context, void 0, {
-      F: __dxlog_file17,
+    (0, import_invariant14.invariant)(this._context, void 0, {
+      F: __dxlog_file18,
       L: 125,
       S: this,
       A: [
@@ -3467,8 +4311,8 @@ var EchoEdgeReplicator = class {
         ""
       ]
     });
-    (0, import_invariant12.invariant)(!this._connections.has(spaceId), void 0, {
-      F: __dxlog_file17,
+    (0, import_invariant14.invariant)(!this._connections.has(spaceId), void 0, {
+      F: __dxlog_file18,
       L: 126,
       S: this,
       A: [
@@ -3493,21 +4337,25 @@ var EchoEdgeReplicator = class {
           return;
         }
         const restartDelay = Math.min(MAX_RESTART_DELAY, INITIAL_RESTART_DELAY * reconnects) + Math.random() * RESTART_DELAY_JITTER;
-        import_log11.log.info("connection restart scheduled", {
+        import_log12.log.info("connection restart scheduled", {
           spaceId,
           reconnects,
           restartDelay
         }, {
-          F: __dxlog_file17,
+          F: __dxlog_file18,
           L: 149,
           S: this,
           C: (f, a) => f(...a)
         });
         restartScheduled = true;
         (0, import_async8.scheduleTask)(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;
             }
@@ -3518,10 +4366,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);
       }
@@ -3562,8 +4411,8 @@ var EdgeReplicatorConnection = class extends import_context12.Resource {
     });
   }
   async _open(ctx) {
-    (0, import_log11.log)("opening...", void 0, {
-      F: __dxlog_file17,
+    (0, import_log12.log)("opening...", void 0, {
+      F: __dxlog_file18,
       L: 252,
       S: this,
       C: (f, a) => f(...a)
@@ -3575,8 +4424,8 @@ var EdgeReplicatorConnection = class extends import_context12.Resource {
     await this._onRemoteConnected();
   }
   async _close() {
-    (0, import_log11.log)("closing...", void 0, {
-      F: __dxlog_file17,
+    (0, import_log12.log)("closing...", void 0, {
+      F: __dxlog_file18,
       L: 267,
       S: this,
       C: (f, a) => f(...a)
@@ -3586,8 +4435,8 @@ var EdgeReplicatorConnection = class extends import_context12.Resource {
     await this._onRemoteDisconnected();
   }
   get peerId() {
-    (0, import_invariant12.invariant)(this._remotePeerId, "Not connected", {
-      F: __dxlog_file17,
+    (0, import_invariant14.invariant)(this._remotePeerId, "Not connected", {
+      F: __dxlog_file18,
       L: 276,
       S: this,
       A: [
@@ -3607,12 +4456,12 @@ var EdgeReplicatorConnection = class extends import_context12.Resource {
         documentId: params.documentId,
         peerId: this._remotePeerId
       });
-      import_log11.log.verbose("document not found locally for share policy check", {
+      import_log12.log.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)
@@ -3633,12 +4482,12 @@ var EdgeReplicatorConnection = class extends import_context12.Resource {
       return;
     }
     const payload = import_automerge_repo6.cbor.decode(message.payload.value);
-    import_log11.log.verbose("received", {
+    import_log12.log.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)
@@ -3656,12 +4505,12 @@ var EdgeReplicatorConnection = class extends import_context12.Resource {
   }
   async _sendMessage(message) {
     message.targetId = this._targetServiceId;
-    import_log11.log.verbose("sending...", {
+    import_log12.log.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)
@@ -3683,7 +4532,8 @@ var isForbiddenErrorMessage = (message) => message.type === "error" && message.m
 var findInlineObjectOfType = (spaceDoc, typename) => {
   for (const id in spaceDoc.objects ?? {}) {
     const obj = spaceDoc.objects[id];
-    if (obj.system.type && (0, import_echo_protocol5.decodeReference)(obj.system.type).objectId === typename) {
+    const objType = import_echo_protocol7.ObjectStructure.getTypeReference(obj);
+    if (objType && (0, import_echo_protocol7.decodeReference)(objType).objectId === typename) {
       return [
         id,
         obj
@@ -3705,6 +4555,7 @@ var findInlineObjectOfType = (spaceDoc, typename) => {
   EchoDataMonitor,
   EchoEdgeReplicator,
   EchoHost,
+  ExecutionTrace,
   FIND_PARAMS,
   LevelDBStorageAdapter,
   MOCK_AUTH_PROVIDER,
@@ -3712,8 +4563,10 @@ var findInlineObjectOfType = (spaceDoc, typename) => {
   MeshEchoReplicator,
   MetadataStore,
   Pipeline,
+  QueryExecutor,
+  QueryPlan,
+  QueryPlanner,
   QueryServiceImpl,
-  QueryState,
   Space,
   SpaceDocumentListUpdatedEvent,
   SpaceManager,
@@ -3727,9 +4580,10 @@ var findInlineObjectOfType = (spaceDoc, typename) => {
   deriveCollectionIdFromSpaceId,
   diffCollectionState,
   encodingOptions,
+  filterMatchObject,
+  filterMatchValue,
   findInlineObjectOfType,
   getSpaceIdFromCollectionId,
-  getSpaceKeyFromDoc,
   hasInvitationExpired,
   mapFeedIndexesToTimeframe,
   mapTimeframeToFeedIndexes,