@dxos/echo-query 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/src/{query-env/index.ts → query-lite/query-lite.ts}

@@ -4,16 +4,21 @@
 
 import type * as Schema from 'effect/Schema';
 
-import type { Filter, Order, Query, Ref } from '@dxos/echo';
-import type * as Echo from '@dxos/echo';
+import type { Filter as Filter$, Order as Order$, Query as Query$, Ref } from '@dxos/echo';
 import type { ForeignKey, QueryAST } from '@dxos/echo-protocol';
 import { assertArgument } from '@dxos/invariant';
 import type { DXN, ObjectId } from '@dxos/keys';
 
-class OrderClass implements Echo.Order<any> {
-  private static variance: Echo.Order<any>['~Order'] = {} as Echo.Order<any>['~Order'];
+//
+// Light-weight implementation of query execution.
+//
+
+// TODO(wittjosiah): The `export * as ...` syntax causes tsdown to genereate multiple files which breaks the sandbox.
 
-  static is(value: unknown): value is Echo.Order<any> {
+class OrderClass implements Order$.Any {
+  private static 'variance': Order$.Any['~Order'] = {} as Order$.Any['~Order'];
+
+  static is(value: unknown): value is Order$.Any {
     return typeof value === 'object' && value !== null && '~Order' in value;
   }
 
@@ -21,27 +26,33 @@ class OrderClass implements Echo.Order<any> {
 
   '~Order' = OrderClass.variance;
 }
+
 namespace Order1 {
-  export const natural: Echo.Order<any> = new OrderClass({ kind: 'natural' });
-  export const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Echo.Order<T> =>
+  export const natural: Order$.Any = new OrderClass({ kind: 'natural' });
+  export const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order$.Order<T> =>
     new OrderClass({
       kind: 'property',
       property,
       direction,
     });
+  export const rank = <T>(direction: QueryAST.OrderDirection = 'desc'): Order$.Order<T> =>
+    new OrderClass({
+      kind: 'rank',
+      direction,
+    });
 }
 
-const Order2: typeof Echo.Order = Order1;
+const Order2: typeof Order$ = Order1;
 export { Order2 as Order };
 
-class FilterClass implements Echo.Filter<any> {
-  private static variance: Echo.Filter<any>['~Filter'] = {} as Echo.Filter<any>['~Filter'];
+class FilterClass implements Filter$.Any {
+  private static 'variance': Filter$.Any['~Filter'] = {} as Filter$.Any['~Filter'];
 
-  static is(value: unknown): value is Echo.Filter<any> {
+  static is(value: unknown): value is Filter$.Any {
     return typeof value === 'object' && value !== null && '~Filter' in value;
   }
 
-  static fromAst(ast: QueryAST.Filter): Filter<any> {
+  static fromAst(ast: QueryAST.Filter): Filter$.Any {
     return new FilterClass(ast);
   }
 
@@ -72,7 +83,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static ids(...ids: ObjectId[]): Echo.Filter<any> {
+  static id(...ids: ObjectId[]): Filter$.Any {
     // assertArgument(
     //   ids.every((id) => ObjectId.isValid(id)),
     //   'ids',
@@ -93,8 +104,8 @@ class FilterClass implements Echo.Filter<any> {
 
   static type<S extends Schema.Schema.All>(
     schema: S | string,
-    props?: Echo.Filter.Props<Schema.Schema.Type<S>>,
-  ): Echo.Filter<Schema.Schema.Type<S>> {
+    props?: Filter$.Props<Schema.Schema.Type<S>>,
+  ): Filter$.Filter<Schema.Schema.Type<S>> {
     if (typeof schema !== 'string') {
       throw new TypeError('expected typename as the first paramter');
     }
@@ -105,7 +116,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static typename(typename: string): Echo.Filter<any> {
+  static typename(typename: string): Filter$.Any {
     return new FilterClass({
       type: 'object',
       typename: makeTypeDxn(typename),
@@ -113,7 +124,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static typeDXN(dxn: DXN): Echo.Filter<any> {
+  static typeDXN(dxn: DXN): Filter$.Any {
     return new FilterClass({
       type: 'object',
       typename: dxn.toString(),
@@ -121,14 +132,14 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static tag(tag: string): Echo.Filter<any> {
+  static tag(tag: string): Filter$.Any {
     return new FilterClass({
       type: 'tag',
       tag,
     });
   }
 
-  static props<T>(props: Echo.Filter.Props<T>): Echo.Filter<T> {
+  static props<T>(props: Filter$.Props<T>): Filter$.Filter<T> {
     return new FilterClass({
       type: 'object',
       typename: null,
@@ -136,7 +147,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static text(text: string, options?: Echo.Query.TextSearchOptions): Echo.Filter<any> {
+  static text(text: string, options?: Filter$.TextSearchOptions): Filter$.Any {
     return new FilterClass({
       type: 'text-search',
       text,
@@ -147,7 +158,7 @@ class FilterClass implements Echo.Filter<any> {
   static foreignKeys<S extends Schema.Schema.All>(
     schema: S | string,
     keys: ForeignKey[],
-  ): Echo.Filter<Schema.Schema.Type<S>> {
+  ): Filter$.Filter<Schema.Schema.Type<S>> {
     assertArgument(typeof schema === 'string', 'schema');
     assertArgument(!schema.startsWith('dxn:'), 'schema');
     return new FilterClass({
@@ -158,7 +169,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static eq<T>(value: T): Echo.Filter<T> {
+  static eq<T>(value: T): Filter$.Filter<T | undefined> {
     if (!isRef(value) && typeof value === 'object' && value !== null) {
       throw new TypeError('Cannot use object as a value for eq filter');
     }
@@ -170,7 +181,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static neq<T>(value: T): Echo.Filter<T> {
+  static neq<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'neq',
@@ -178,7 +189,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static gt<T>(value: T): Echo.Filter<T> {
+  static gt<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'gt',
@@ -186,7 +197,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static gte<T>(value: T): Echo.Filter<T> {
+  static gte<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'gte',
@@ -194,7 +205,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static lt<T>(value: T): Echo.Filter<T> {
+  static lt<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'lt',
@@ -202,7 +213,7 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static lte<T>(value: T): Echo.Filter<T> {
+  static lte<T>(value: T): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'compare',
       operator: 'lte',
@@ -210,21 +221,21 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static in<T>(...values: T[]): Echo.Filter<T> {
+  static in<T>(...values: T[]): Filter$.Filter<T | undefined> {
     return new FilterClass({
       type: 'in',
       values,
     });
   }
 
-  static contains<T>(value: T): Echo.Filter<T[]> {
+  static contains<T>(value: T): Filter$.Filter<readonly T[] | undefined> {
     return new FilterClass({
       type: 'contains',
       value,
     });
   }
 
-  static between<T>(from: T, to: T): Echo.Filter<T> {
+  static between<T>(from: T, to: T): Filter$.Filter<unknown> {
     return new FilterClass({
       type: 'range',
       from,
@@ -232,21 +243,25 @@ class FilterClass implements Echo.Filter<any> {
     });
   }
 
-  static not<F extends Echo.Filter.Any>(filter: F): Echo.Filter<Echo.Filter.Type<F>> {
+  static not<F extends Filter$.Any>(filter: F): Filter$.Filter<Filter$.Type<F>> {
     return new FilterClass({
       type: 'not',
       filter: filter.ast,
     });
   }
 
-  static and<T>(...filters: Echo.Filter<T>[]): Echo.Filter<T> {
+  static and<Filters extends readonly Filter$.Any[]>(
+    ...filters: Filters
+  ): Filter$.Filter<Filter$.Type<Filters[number]>> {
     return new FilterClass({
       type: 'and',
       filters: filters.map((f) => f.ast),
     });
   }
 
-  static or<T>(...filters: Echo.Filter<T>[]): Echo.Filter<T> {
+  static or<Filters extends readonly Filter$.Any[]>(
+    ...filters: Filters
+  ): Filter$.Filter<Filter$.Type<Filters[number]>> {
     return new FilterClass({
       type: 'or',
       filters: filters.map((f) => f.ast),
@@ -258,7 +273,7 @@ class FilterClass implements Echo.Filter<any> {
   '~Filter' = FilterClass.variance;
 }
 
-export const Filter1: typeof Echo.Filter = FilterClass;
+export const Filter1: typeof Filter$ = FilterClass;
 export { Filter1 as Filter };
 
 /**
@@ -267,7 +282,7 @@ export { Filter1 as Filter };
 // TODO(dmaretskyi): Filter only properties that are references (or optional references, or unions that include references).
 type RefPropKey<T> = keyof T & string;
 
-const propsFilterToAst = (predicates: Echo.Filter.Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {
+const propsFilterToAst = (predicates: Filter$.Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {
   let idFilter: readonly ObjectId[] | undefined;
   if ('id' in predicates) {
     assertArgument(
@@ -312,32 +327,32 @@ const processPredicate = (predicate: any): QueryAST.Filter => {
   return FilterClass.eq(predicate).ast;
 };
 
-class QueryClass implements Echo.Query<any> {
-  private static variance: Echo.Query<any>['~Query'] = {} as Echo.Query<any>['~Query'];
+class QueryClass implements Query$.Any {
+  private static 'variance': Query$.Any['~Query'] = {} as Query$.Any['~Query'];
 
-  static is(value: unknown): value is Echo.Query<any> {
+  static is(value: unknown): value is Query$.Any {
     return typeof value === 'object' && value !== null && '~Query' in value;
   }
 
-  static fromAst(ast: QueryAST.Query): Echo.Query<any> {
+  static fromAst(ast: QueryAST.Query): Query$.Any {
     return new QueryClass(ast);
   }
 
-  static select<F extends Echo.Filter.Any>(filter: F): Echo.Query<Echo.Filter.Type<F>> {
+  static select<F extends Filter$.Any>(filter: F): Query$.Query<Filter$.Type<F>> {
     return new QueryClass({
       type: 'select',
       filter: filter.ast,
     });
   }
 
-  static type(schema: Schema.Schema.All | string, predicates?: Echo.Filter.Props<unknown>): Query<any> {
+  static type(schema: Schema.Schema.All | string, predicates?: Filter$.Props<unknown>): Query$.Any {
     return new QueryClass({
       type: 'select',
       filter: FilterClass.type(schema, predicates).ast,
     });
   }
 
-  static all(...queries: Query<any>[]): Query<any> {
+  static all(...queries: Query$.Any[]): Query$.Any {
     if (queries.length === 0) {
       throw new TypeError(
         'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',
@@ -349,7 +364,7 @@ class QueryClass implements Echo.Query<any> {
     });
   }
 
-  static without<T>(source: Query<T>, exclude: Query<T>): Query<T> {
+  static without<T>(source: Query$.Query<T>, exclude: Query$.Query<T>): Query$.Query<T> {
     return new QueryClass({
       type: 'set-difference',
       source: source.ast,
@@ -357,11 +372,20 @@ class QueryClass implements Echo.Query<any> {
     });
   }
 
+  static from(source: any, options?: { includeFeeds?: boolean }): Query$.Any {
+    const baseQuery: QueryAST.Query = {
+      type: 'select',
+      filter: FilterClass.everything().ast,
+    };
+    const wrapper = new QueryClass(baseQuery);
+    return wrapper.from(source, options);
+  }
+
   constructor(public readonly ast: QueryAST.Query) {}
 
   '~Query' = QueryClass.variance;
 
-  select(filter: Filter<any> | Filter.Props<any>): Query<any> {
+  select(filter: Filter$.Any | Filter$.Props<any>): Query$.Any {
     if (FilterClass.is(filter)) {
       return new QueryClass({
         type: 'filter',
@@ -377,7 +401,7 @@ class QueryClass implements Echo.Query<any> {
     }
   }
 
-  reference(key: string): Query<any> {
+  reference(key: string): Query$.Any {
     return new QueryClass({
       type: 'reference-traversal',
       anchor: this.ast,
@@ -385,36 +409,40 @@ class QueryClass implements Echo.Query<any> {
     });
   }
 
-  referencedBy(target: Schema.Schema.All | string, key: string): Query<any> {
-    assertArgument(typeof target === 'string', 'target');
-    assertArgument(!target.startsWith('dxn:'), 'target');
+  referencedBy(target?: Schema.Schema.All | string, key?: string): Query$.Any {
+    const typename =
+      target !== undefined
+        ? (assertArgument(typeof target === 'string', 'target'),
+          assertArgument(!target.startsWith('dxn:'), 'target'),
+          target)
+        : null;
     return new QueryClass({
       type: 'incoming-references',
       anchor: this.ast,
-      property: key,
-      typename: target,
+      property: key ?? null,
+      typename,
     });
   }
 
-  sourceOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Query<any> {
+  sourceOf(relation?: Schema.Schema.All | string, predicates?: Filter$.Props<unknown> | undefined): Query$.Any {
     return new QueryClass({
       type: 'relation',
       anchor: this.ast,
       direction: 'outgoing',
-      filter: FilterClass.type(relation, predicates).ast,
+      filter: relation !== undefined ? FilterClass.type(relation, predicates).ast : undefined,
     });
   }
 
-  targetOf(relation: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Query<any> {
+  targetOf(relation?: Schema.Schema.All | string, predicates?: Filter$.Props<unknown> | undefined): Query$.Any {
     return new QueryClass({
       type: 'relation',
       anchor: this.ast,
       direction: 'incoming',
-      filter: FilterClass.type(relation, predicates).ast,
+      filter: relation !== undefined ? FilterClass.type(relation, predicates).ast : undefined,
     });
   }
 
-  source(): Query<any> {
+  source(): Query$.Any {
     return new QueryClass({
       type: 'relation-traversal',
       anchor: this.ast,
@@ -422,7 +450,7 @@ class QueryClass implements Echo.Query<any> {
     });
   }
 
-  target(): Query<any> {
+  target(): Query$.Any {
     return new QueryClass({
       type: 'relation-traversal',
       anchor: this.ast,
@@ -430,7 +458,23 @@ class QueryClass implements Echo.Query<any> {
     });
   }
 
-  orderBy(...order: Order<any>[]): Query<any> {
+  parent(): Query$.Any {
+    return new QueryClass({
+      type: 'hierarchy-traversal',
+      anchor: this.ast,
+      direction: 'to-parent',
+    });
+  }
+
+  children(): Query$.Any {
+    return new QueryClass({
+      type: 'hierarchy-traversal',
+      anchor: this.ast,
+      direction: 'to-children',
+    });
+  }
+
+  orderBy(...order: Order$.Any[]): Query$.Any {
     return new QueryClass({
       type: 'order',
       query: this.ast,
@@ -438,7 +482,40 @@ class QueryClass implements Echo.Query<any> {
     });
   }
 
-  options(options: QueryAST.QueryOptions): Query<any> {
+  limit(limit: number): Query$.Any {
+    return new QueryClass({
+      type: 'limit',
+      query: this.ast,
+      limit,
+    });
+  }
+
+  from(arg: any, options?: { includeFeeds?: boolean }): Query$.Any {
+    if (arg === 'all-accessible-spaces') {
+      return new QueryClass({
+        type: 'from',
+        query: this.ast,
+        from: {
+          _tag: 'scope',
+          scope: {
+            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),
+          },
+        },
+      });
+    }
+
+    if (_isScopeLike(arg)) {
+      return new QueryClass({
+        type: 'from',
+        query: this.ast,
+        from: { _tag: 'scope', scope: arg },
+      });
+    }
+
+    throw new TypeError('Database and Feed objects are not supported in query-lite sandbox');
+  }
+
+  options(options: QueryAST.QueryOptions): Query$.Any {
     return new QueryClass({
       type: 'options',
       query: this.ast,
@@ -447,7 +524,7 @@ class QueryClass implements Echo.Query<any> {
   }
 }
 
-export const Query1: typeof Echo.Query = QueryClass;
+export const Query1: typeof Query$ = QueryClass;
 export { Query1 as Query };
 
 const RefTypeId: unique symbol = Symbol('@dxos/echo-query/Ref');
@@ -460,3 +537,12 @@ const makeTypeDxn = (typename: string) => {
   assertArgument(!typename.startsWith('dxn:'), 'typename');
   return `dxn:type:${typename}`;
 };
+
+const SCOPE_KEYS = new Set(['spaceIds', 'queues', 'allQueuesFromSpaces']);
+
+const _isScopeLike = (value: unknown): value is QueryAST.Scope => {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    return false;
+  }
+  return Object.keys(value).every((key) => SCOPE_KEYS.has(key));
+};

package/src/sandbox/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './query-sandbox';

package/src/sandbox/query-sandbox.test.ts

@@ -5,6 +5,7 @@
 import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 
 import { Filter, Order, Query } from '@dxos/echo';
+import { trim } from '@dxos/util';
 
 import { QuerySandbox } from './query-sandbox';
 
@@ -14,38 +15,38 @@ describe('QuerySandbox', () => {
   afterAll(() => sandbox.close());
 
   test('works', { timeout: 10_000 }, async () => {
-    const ast = sandbox.eval(`
+    const ast = sandbox.eval(trim`
       Query.select(Filter.typename('dxos.org/type/Person'))
     `);
     expect(ast).toEqual(Query.select(Filter.typename('dxos.org/type/Person')).ast);
   });
 
   test('works with just Filter passed in', () => {
-    const ast = sandbox.eval(`
+    const ast = sandbox.eval(trim`
       Filter.typename('dxos.org/type/Person')
     `);
     expect(ast).toEqual(Query.select(Filter.typename('dxos.org/type/Person')).ast);
   });
 
   test('Order', () => {
-    const ast = sandbox.eval(`
+    const ast = sandbox.eval(trim`
       Query.type('dxos.org/type/Person').orderBy(Order.property('name', 'desc'))
     `);
     expect(ast).toEqual(Query.type('dxos.org/type/Person').orderBy(Order.property('name', 'desc')).ast);
   });
 
   test('traversal', () => {
-    const ast = sandbox.eval(`
-      Query.select(Filter.type('example.com/type/Person', { jobTitle: 'investor' }))
+    const ast = sandbox.eval(trim`
+      Query.select(Filter.type('dxos.org/type/Person', { jobTitle: 'investor' }))
         .reference('organization')
-        .targetOf('example.com/relation/ResearchOn')
+        .targetOf('dxos.org/relation/HasSubject')
         .source()
     `);
 
     expect(ast).toEqual(
-      Query.select(Filter.type('example.com/type/Person', { jobTitle: 'investor' }))
+      Query.select(Filter.type('dxos.org/type/Person', { jobTitle: 'investor' }))
         .reference('organization')
-        .targetOf('example.com/relation/ResearchOn')
+        .targetOf('dxos.org/relation/HasSubject')
         .source().ast,
     );
   });

package/src/sandbox/query-sandbox.ts

@@ -7,7 +7,7 @@ import { Query, type QueryAST } from '@dxos/echo';
 import { trim } from '@dxos/util';
 import { type QuickJSRuntime, type QuickJSWASMModule, createQuickJS } from '@dxos/vendor-quickjs';
 
-import envCode from '#query-env?raw';
+import envCode from '#query-lite?raw';
 
 import { unwrapResult } from './quickjs';
 
@@ -34,7 +34,7 @@ export class QuerySandbox extends Resource {
     this.#runtime = quickJS.newRuntime({
       moduleLoader: (moduleName, _context) => {
         switch (moduleName) {
-          case 'dxos:query-env':
+          case 'dxos:query-lite':
             return envCode;
           default:
             throw new Error(`Module not found: ${moduleName}`);
@@ -54,7 +54,7 @@ export class QuerySandbox extends Resource {
   eval(queryCode: string): QueryAST.Query {
     using context = this.#runtime.newContext();
     const globals = trim`
-      import { Filter, Order, Query } from 'dxos:query-env';
+      import { Filter, Order, Query } from 'dxos:query-lite';
       globalThis.Filter = Filter;
       globalThis.Order = Order;
       globalThis.Query = Query;

package/src/sandbox/quickjs.ts

@@ -17,8 +17,7 @@ export const unwrapResult = <T>(context: QuickJSContext, result: SuccessOrFail<T
     if (
       typeof contextError === 'object' &&
       typeof contextError.name === 'string' &&
-      typeof contextError.message === 'string' &&
-      typeof contextError.stack === 'string'
+      typeof contextError.message === 'string'
     ) {
       const error = new Error(contextError.message);
       Object.defineProperty(error, 'name', { value: contextError.name });

package/dist/lib/browser/index.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/parser/gen/query.ts", "../../../src/parser/gen/query.terms.ts", "../../../src/parser/gen/index.ts", "../../../src/parser/query-builder.ts"],
-  "sourcesContent": ["// This file was generated by lezer-generator. You probably shouldn't edit it.\nimport {LRParser} from \"@lezer/lr\"\nconst spec_Identifier = {__proto__:null,type:18, NOT:82, not:82, \"!\":82, AND:84, and:84, OR:86, or:86}\nexport const parser = LRParser.deserialize({\n  version: 14,\n  states: \"(QOVQPOOOOQO'#C_'#C_OOQO'#Ca'#CaOnQPO'#CcOsQPO'#ChO{QPO'#CnO!TQPO'#CgOOQO'#C^'#C^OOQO'#Cv'#CvOOQO'#DU'#DUOVQPO'#DUQ!YQPOOOVQPO'#DUO!jQPO,58}O!oQPO'#DOO!tQPO,59SO!|QPO'#CpOOQO,59Y,59YO#RQPO,59YO#ZQQO,59RO#oQPO,59pOOQO'#Cw'#CwOOQO'#Cx'#CxOOQO'#Cy'#CyOVQPO,59pOVQPO,59pOVQPO,59pO$jQPO,59pOOQO1G.i1G.iOOQO,59j,59jOOQO-E6|-E6|O#ZQQO,59[O$}QPO'#DPO%SQPO1G.tOOQO1G.t1G.tO%[QQO'#CsOOQO'#Cj'#CjOOQO1G.m1G.mO%cQPO1G/[O%yQPO1G/[O&aQPO1G/[OOQO1G/[1G/[OOQO1G.v1G.vOOQO,59k,59kOOQO-E6}-E6}OOQO7+$`7+$`OOQO,59_,59_O&wQPO,59_O#ZQQO'#DQO'PQPO1G.yOOQO1G.y1G.yOOQO,59l,59lOOQO-E7O-E7OOOQO7+$e7+$e\",\n  stateData: \"'X~OwOS~OSPOUQOWSOXROcTOp[OyWO~OY]O~O]^OY[X~OW`OfaO~OYcO~OngOogOzeO{fO~PVOWlO~OWmO~O]^OY[a~OYoO~OepOfrO~OUtO_tO`tOatOcTOhsO~OyWOSxaUxaWxaXxacxanxaoxapxauxazxa{xaqxa~OngOogOqyOzeO{fO~PVOW`O~OepOf}O~Oi!OO~P#ZOnxioxiuxizxi{xiqxi~PVOzeOnxioxiuxi{xiqxi~PVOzeO{fOnxioxiuxiqxi~PVOe!QOi!SO~Oe!QOi!VO~O\",\n  goto: \"%TyPPz!XP!XP!XPPP!X!fP!sPPP#PP#dPP#^PP#j#x$O$TPPPP$X$_$ePPP$kgXOYZ[hijkvwxgVOYZ[hijkvwxgUOYZ[hijkvwxQucQzoQ!PsR!T!QfVOYZ[hijkvwxXtcos!QQbTR{piYOYZ[dhijkvwxXhZkwxViZkxTjZkQ_SRn_QqbR|qQ!R!PR!U!RQZO^dYZdkvwxQk[QvhQwiRxj\",\n  nodeNames: \"⚠ Query Filter TagFilter Tag TextFilter String TypeFilter Identifier TypeKeyword : PropertyFilter PropertyPath . Value Number Boolean Null ObjectLiteral { ObjectProperty , } ArrayLiteral [ ] Not And Or Relation ArrowRight ArrowLeft ( )\",\n  maxTerm: 43,\n  skippedNodes: [0],\n  repeatNodeCount: 3,\n  tokenData: \"2w~RrX^#]pq#]rs$Qst%nwx&fxy'}yz(S|}(X}!O(^!O!P)}!Q![(g![!]*S!^!_*X!c!}*d!}#O+O#P#Q+T#R#S*d#T#Y*d#Y#Z+Y#Z#b*d#b#c.i#c#h*d#h#i1Z#i#o*d#o#p2m#q#r2r#y#z#]$f$g#]#BY#BZ#]$IS$I_#]$I|$JO#]$JT$JU#]$KV$KW#]&FU&FV#]~#bYw~X^#]pq#]#y#z#]$f$g#]#BY#BZ#]$IS$I_#]$I|$JO#]$JT$JU#]$KV$KW#]&FU&FV#]~$TVOr$Qrs$js#O$Q#O#P$o#P;'S$Q;'S;=`%h<%lO$Q~$oOU~~$rRO;'S$Q;'S;=`${;=`O$Q~%OWOr$Qrs$js#O$Q#O#P$o#P;'S$Q;'S;=`%h;=`<%l$Q<%lO$Q~%kP;=`<%l$Q~%qT}!O&Q!Q![&Q!c!}&Q#R#S&Q#T#o&Q~&VTS~}!O&Q!Q![&Q!c!}&Q#R#S&Q#T#o&Q~&iVOw&fwx$jx#O&f#O#P'O#P;'S&f;'S;=`'w<%lO&f~'RRO;'S&f;'S;=`'[;=`O&f~'_WOw&fwx$jx#O&f#O#P'O#P;'S&f;'S;=`'w;=`<%l&f<%lO&f~'zP;=`<%l&f~(SOp~~(XOq~~(^Oe~~(aQ!Q![(g!`!a)x~(lS_~!O!P(x!Q![(g!g!h)^#X#Y)^~({P!Q![)O~)TR_~!Q![)O!g!h)^#X#Y)^~)aR{|)j}!O)j!Q![)p~)mP!Q![)p~)uP_~!Q![)p~)}On~~*SO]~~*XOY~~*[P}!O*_~*dOo~P*iVWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#o*d~+TOh~~+YOi~R+_WWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#U+w#U#o*dR+|XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#`*d#`#a,i#a#o*dR,nXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#g*d#g#h-Z#h#o*dR-`XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#X*d#X#Y-{#Y#o*dR.SV`QWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#o*dR.nXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#i*d#i#j/Z#j#o*dR/`XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#`*d#`#a/{#a#o*dR0QXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#`*d#`#a0m#a#o*dR0tVWPaQ}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#o*dR1`XWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#f*d#f#g1{#g#o*dR2QXWP}!O*d!O!P*d!P!Q*d!Q![*d!c!}*d#R#S*d#T#i*d#i#j-Z#j#o*d~2rOc~~2wOf~\",\n  tokenizers: [0, 1],\n  topRules: {\"Query\":[0,1]},\n  specialized: [{term: 8, get: (value: keyof typeof spec_Identifier) => spec_Identifier[value] || -1}],\n  tokenPrec: 0\n})\n", "// This file was generated by lezer-generator. You probably shouldn't edit it.\nexport const\n  Query = 1,\n  Filter = 2,\n  TagFilter = 3,\n  Tag = 4,\n  TextFilter = 5,\n  String = 6,\n  TypeFilter = 7,\n  Identifier = 8,\n  TypeKeyword = 9,\n  PropertyFilter = 11,\n  PropertyPath = 12,\n  Value = 14,\n  Number = 15,\n  Boolean = 16,\n  Null = 17,\n  ObjectLiteral = 18,\n  ObjectProperty = 20,\n  ArrayLiteral = 23,\n  Not = 26,\n  And = 27,\n  Or = 28,\n  Relation = 29,\n  ArrowRight = 30,\n  ArrowLeft = 31\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { LRParser } from '@lezer/lr';\nimport { parser } from './query';\nimport * as terms from './query.terms';\n\nexport namespace QueryDSL {\n  export const Parser: LRParser = parser;\n  export const Node = terms;\n  export const Tokens = ['type:', 'AND', 'OR', 'NOT'];\n}\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type Parser, type Tree, type TreeCursor } from '@lezer/common';\n\nimport { Filter, type TagMap } from '@dxos/echo';\nimport { invariant } from '@dxos/invariant';\n\nimport { QueryDSL } from './gen';\n\n/**\n * Stateless query builder that parses DSL trees into filters.\n *\n * NOTE: QueryBuilder was largely developed using Claude Sonnet 4.5 (in Windsurf)..\n * To modify the functionality, create a minimal breaking test and direct the LLM to fix either the grammar or builder.\n */\nexport class QueryBuilder {\n  private readonly _parser: Parser = QueryDSL.Parser.configure({ strict: true });\n\n  constructor(private readonly _tags?: TagMap) {}\n\n  /**\n   * Check valid input.\n   */\n  validate(input: string): boolean {\n    try {\n      const tree = this._parser.parse(input);\n      return tree.cursor().node.name === 'Query';\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Build a query from the input string.\n   */\n  build(input: string): Filter.Any | undefined {\n    try {\n      const tree = this._parser.parse(input);\n      return this.buildQuery(tree, input);\n    } catch {\n      return undefined;\n    }\n  }\n\n  /**\n   * Build a query from a parsed DSL tree.\n   */\n  buildQuery(tree: Tree, input: string): Filter.Any | undefined {\n    const cursor = tree.cursor();\n\n    // Start at root (Query node).\n    if (cursor.node.name !== 'Query') {\n      return undefined;\n    }\n\n    // Check if Query has multiple children (binary expression).\n    const children: Array<{ name: string; from: number; to: number }> = [];\n    if (cursor.firstChild()) {\n      do {\n        children.push({ name: cursor.node.name, from: cursor.from, to: cursor.to });\n      } while (cursor.nextSibling());\n      cursor.parent();\n    }\n\n    // If we have an operator in the children, or multiple expressions (implicit AND), parse as binary expression.\n    const hasOperator = children.some((child) => child.name === 'And' || child.name === 'Or');\n    const hasMultipleExpressions =\n      children.filter((child) => child.name === 'Filter' || child.name === 'Not' || child.name === '(').length > 1;\n    if (hasOperator || hasMultipleExpressions) {\n      return this._parseBinaryExpression(cursor, input);\n    }\n\n    // Otherwise, parse the single expression.\n    if (!cursor.firstChild()) {\n      return Filter.nothing();\n    }\n\n    return this._parseExpression(cursor, input);\n  }\n\n  /**\n   * Parse an expression node.\n   */\n  private _parseExpression(cursor: TreeCursor, input: string): Filter.Any | undefined {\n    const nodeName = cursor.node.name;\n\n    switch (nodeName) {\n      case 'Filter':\n        return this._parseFilter(cursor, input);\n\n      case 'Not': {\n        // Move past NOT token to the expression.\n        cursor.nextSibling();\n        const notFilter = this._parseExpression(cursor, input);\n        return notFilter ? Filter.not(notFilter) : undefined;\n      }\n\n      case 'And':\n      case 'Or':\n        // This is the operator node, we need to handle the binary expression.\n        // The cursor is positioned at the operator, we need to go back to parent.\n        cursor.parent();\n        return this._parseBinaryExpression(cursor, input);\n\n      case '(': {\n        // Skip opening paren.\n        cursor.nextSibling();\n        const parenFilter = this._parseExpression(cursor, input);\n        // Skip closing paren.\n        cursor.nextSibling();\n        return parenFilter;\n      }\n\n      default: {\n        // Check if this is a binary expression (has And/Or as a child).\n        const savedPos = cursor.from;\n        if (cursor.firstChild()) {\n          // Look for And/Or operators or multiple expressions (implicit AND).\n          let hasOperator = false;\n          let expressionCount = 0;\n          do {\n            if (cursor.node.name === 'And' || cursor.node.name === 'Or') {\n              hasOperator = true;\n              break;\n            }\n            if (cursor.node.name === 'Filter' || cursor.node.name === 'Not' || cursor.node.name === '(') {\n              expressionCount++;\n            }\n          } while (cursor.nextSibling());\n          hasOperator = hasOperator || expressionCount > 1;\n\n          // Reset cursor to the saved position.\n          cursor.parent();\n          cursor.firstChild();\n          while (cursor.from !== savedPos && cursor.nextSibling()) {}\n\n          if (hasOperator) {\n            cursor.parent();\n            return this._parseBinaryExpression(cursor, input);\n          } else {\n            const result = this._parseExpression(cursor, input);\n            cursor.parent();\n            return result;\n          }\n        }\n        return Filter.nothing();\n      }\n    }\n  }\n\n  /**\n   * Parse a binary expression (AND/OR).\n   */\n  private _parseBinaryExpression(cursor: TreeCursor, input: string): Filter.Any {\n    const filters: Filter.Any[] = [];\n    let operator: 'and' | 'or' | null = null;\n\n    // Collect all filters and operators.\n    if (cursor.firstChild()) {\n      do {\n        const nodeName = cursor.node.name;\n\n        if (nodeName === 'And' || nodeName === 'Or') {\n          operator = nodeName.toLowerCase() as 'and' | 'or';\n        } else if (nodeName === '(') {\n          // Handle parenthesized expression.\n          // Look ahead to see if this is a binary expression.\n          const savedPos = cursor.from;\n          cursor.nextSibling(); // Move past '('\n\n          // Check if the parentheses contain a binary expression.\n          let hasBinaryOp = false;\n          do {\n            if (cursor.node.name === 'And' || cursor.node.name === 'Or') {\n              hasBinaryOp = true;\n              break;\n            }\n          } while (cursor.nextSibling() && cursor.node.name !== ')');\n\n          // Reset cursor to start of parenthesized content.\n          cursor.parent();\n          cursor.firstChild();\n          while (cursor.from !== savedPos && cursor.nextSibling()) {}\n          cursor.nextSibling(); // Move past '(' again.\n\n          if (hasBinaryOp) {\n            // Find the matching closing parenthesis.\n            let depth = 1;\n            const exprStart = cursor.from;\n            let exprEnd = cursor.to;\n\n            while (cursor.nextSibling() && depth > 0) {\n              if (cursor.node.name === '(') depth++;\n              else if (cursor.node.name === ')') {\n                depth--;\n                if (depth === 0) {\n                  exprEnd = cursor.from;\n                }\n              }\n            }\n\n            // Parse the expression inside parentheses as a subtree.\n            const subInput = input.slice(exprStart, exprEnd);\n            const subTree = this._parser.parse(subInput);\n            const subFilter = this.buildQuery(subTree, subInput);\n            if (subFilter) {\n              filters.push(subFilter);\n            }\n          } else {\n            // Simple parenthesized expression.\n            const subFilter = this._parseExpression(cursor, input);\n            if (subFilter) {\n              filters.push(subFilter);\n            }\n\n            // Skip until we find the closing parenthesis.\n            while (cursor.nextSibling() && cursor.node.name !== ')') {}\n          }\n        } else if (nodeName !== ')') {\n          const subFilter = this._parseExpression(cursor, input);\n          if (subFilter) {\n            filters.push(subFilter);\n          }\n        }\n      } while (cursor.nextSibling());\n\n      cursor.parent();\n    }\n\n    if (filters.length === 0) {\n      return Filter.nothing();\n    }\n\n    if (filters.length === 1) {\n      return filters[0];\n    }\n\n    return operator === 'or' ? Filter.or(...filters) : Filter.and(...filters);\n  }\n\n  /**\n   * Parse a Filter node.\n   */\n  private _parseFilter(cursor: TreeCursor, input: string): Filter.Any | undefined {\n    if (!cursor.firstChild()) {\n      return Filter.nothing();\n    }\n\n    let result: Filter.Any | undefined = undefined;\n    const filterType = cursor.node.name;\n    switch (filterType) {\n      case 'TagFilter':\n        if (this._tags) {\n          result = this._parseTagFilter(cursor, input);\n        }\n        break;\n\n      case 'TextFilter':\n        result = this._parseTextFilter(cursor, input);\n        break;\n\n      case 'TypeFilter':\n        result = this._parseTypeFilter(cursor, input);\n        break;\n\n      case 'ObjectLiteral':\n        result = this._parseObjectLiteral(cursor, input);\n        break;\n\n      case 'PropertyFilter':\n        result = this._parsePropertyFilter(cursor, input);\n        break;\n\n      default:\n        result = Filter.nothing();\n    }\n\n    cursor.parent();\n    return result;\n  }\n\n  /**\n   * Parse a TypeFilter node (type:typename).\n   */\n  private _parseTypeFilter(cursor: TreeCursor, input: string): Filter.Any {\n    // Skip TypeKeyword.\n    cursor.firstChild();\n    cursor.nextSibling(); // Skip ':'\n    cursor.nextSibling(); // Move to Identifier\n\n    const typename = this._getNodeText(cursor, input);\n    cursor.parent(); // Go back to TypeFilter.\n    return Filter.typename(typename);\n  }\n\n  /**\n   * Parse a TextFilter node (quoted string).\n   */\n  private _parseTextFilter(cursor: TreeCursor, input: string): Filter.Any {\n    cursor.firstChild(); // Move to String node.\n    const text = this._getNodeText(cursor, input);\n    cursor.parent(); // Go back to TextFilter.\n    // Remove quotes.\n    return Filter.text(text.slice(1, -1));\n  }\n\n  /**\n   * Parse an ObjectLiteral node.\n   */\n  private _parseObjectLiteral(cursor: TreeCursor, input: string): Filter.Any {\n    const props: Record<string, any> = {};\n\n    if (cursor.firstChild()) {\n      do {\n        if (cursor.node.name === 'ObjectProperty') {\n          const { key, value } = this._parseObjectProperty(cursor, input);\n          if (key) {\n            // Convert simple values to Filter.eq for compatibility with Filter.props.\n            props[key] = Filter.eq(value);\n          }\n        }\n      } while (cursor.nextSibling());\n\n      cursor.parent();\n    }\n\n    return Filter.props(props);\n  }\n\n  /**\n   * Parse an ObjectProperty node.\n   */\n  private _parseObjectProperty(cursor: TreeCursor, input: string): { key: string | null; value: any } {\n    let key: string | null = null;\n    let value: any = null;\n\n    if (cursor.firstChild()) {\n      // First child should be the property name (Identifier).\n      if (cursor.node.name === 'Identifier') {\n        key = this._getNodeText(cursor, input);\n      }\n\n      // Skip ':' and move to Value.\n      cursor.nextSibling();\n      cursor.nextSibling();\n\n      if (cursor.node.name === 'Value' && cursor.firstChild()) {\n        value = this._parseValue(cursor, input);\n        cursor.parent();\n      }\n\n      cursor.parent();\n    }\n\n    return { key, value };\n  }\n\n  /**\n   * Parse a PropertyFilter node (property:value).\n   */\n  private _parsePropertyFilter(cursor: TreeCursor, input: string): Filter.Any {\n    let path: string | null = null;\n    let value: any = null;\n\n    if (cursor.firstChild()) {\n      // First child is PropertyPath.\n      if (cursor.node.name === 'PropertyPath') {\n        path = this._parsePropertyPath(cursor, input);\n      }\n\n      // Skip ':' and move to Value.\n      cursor.nextSibling();\n      cursor.nextSibling();\n\n      if (cursor.node.name === 'Value' && cursor.firstChild()) {\n        value = this._parseValue(cursor, input);\n        cursor.parent();\n      }\n\n      cursor.parent();\n    }\n\n    if (!path) {\n      return Filter.nothing();\n    }\n\n    return Filter.props({ [path]: value });\n  }\n\n  /**\n   * Parse a PropertyPath node (supports dot notation).\n   */\n  private _parsePropertyPath(cursor: TreeCursor, input: string): string {\n    const parts: string[] = [];\n\n    if (cursor.firstChild()) {\n      do {\n        if (cursor.node.name === 'Identifier') {\n          parts.push(this._getNodeText(cursor, input));\n        }\n      } while (cursor.nextSibling());\n\n      cursor.parent();\n    }\n\n    return parts.join('.');\n  }\n\n  /**\n   * Parse a TagFilter node (#tag).\n   */\n  private _parseTagFilter(cursor: TreeCursor, input: string): Filter.Any | undefined {\n    invariant(this._tags);\n    const str = this._getNodeText(cursor, input).slice(1).toLowerCase();\n    const [key] = Object.entries(this._tags!).find(([, value]) => value.label.toLowerCase() === str) ?? [];\n    return key ? Filter.tag(key) : undefined;\n  }\n\n  /**\n   * Parse a Value node.\n   */\n  private _parseValue(cursor: TreeCursor, input: string): any {\n    const valueType = cursor.node.name;\n\n    switch (valueType) {\n      case 'String': {\n        // Remove quotes.\n        const str = this._getNodeText(cursor, input);\n        return str.slice(1, -1);\n      }\n\n      case 'Number':\n        return Number(this._getNodeText(cursor, input));\n\n      case 'Boolean':\n        return this._getNodeText(cursor, input) === 'true';\n\n      case 'Null':\n        return null;\n\n      case 'ObjectLiteral': {\n        // For nested objects, parse recursively.\n        const props: Record<string, any> = {};\n        if (cursor.firstChild()) {\n          do {\n            if (cursor.node.name === 'ObjectProperty') {\n              const { key, value } = this._parseObjectProperty(cursor, input);\n              if (key) {\n                props[key] = value;\n              }\n            }\n          } while (cursor.nextSibling());\n          cursor.parent();\n        }\n        return props;\n      }\n\n      case 'ArrayLiteral': {\n        // Parse array values\n        const array: any[] = [];\n        if (cursor.firstChild()) {\n          do {\n            if (cursor.node.name === 'Value' && cursor.firstChild()) {\n              array.push(this._parseValue(cursor, input));\n              cursor.parent();\n            }\n          } while (cursor.nextSibling());\n          cursor.parent();\n        }\n        return array;\n      }\n\n      default:\n        return null;\n    }\n  }\n\n  /**\n   * Get the text content of the current node.\n   */\n  private _getNodeText(cursor: TreeCursor, input: string): string {\n    return input.slice(cursor.from, cursor.to);\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["LRParser", "spec_Identifier", "__proto__", "type", "NOT", "not", "AND", "and", "OR", "or", "parser", "LRParser", "deserialize", "version", "states", "stateData", "goto", "nodeNames", "maxTerm", "skippedNodes", "repeatNodeCount", "tokenData", "tokenizers", "topRules", "specialized", "term", "get", "value", "tokenPrec", "Number", "Query", "Filter", "TagFilter", "Tag", "TextFilter", "String", "TypeFilter", "Identifier", "TypeKeyword", "PropertyFilter", "PropertyPath", "Value", "Number", "Boolean", "Null", "ObjectLiteral", "ObjectProperty", "ArrayLiteral", "Not", "And", "Or", "Relation", "ArrowRight", "ArrowLeft", "QueryDSL", "Parser", "parser", "Node", "terms", "Tokens", "Filter", "invariant", "QueryBuilder", "validate", "input", "tree", "_parser", "parse", "cursor", "node", "name", "build", "buildQuery", "undefined", "children", "firstChild", "push", "from", "to", "nextSibling", "parent", "hasOperator", "some", "child", "hasMultipleExpressions", "filter", "length", "_parseBinaryExpression", "Filter", "nothing", "_parseExpression", "nodeName", "_parseFilter", "notFilter", "not", "parenFilter", "savedPos", "expressionCount", "result", "filters", "operator", "toLowerCase", "hasBinaryOp", "depth", "exprStart", "exprEnd", "subInput", "slice", "subTree", "subFilter", "or", "and", "filterType", "_tags", "_parseTagFilter", "_parseTextFilter", "_parseTypeFilter", "_parseObjectLiteral", "_parsePropertyFilter", "typename", "_getNodeText", "text", "props", "key", "value", "_parseObjectProperty", "eq", "_parseValue", "path", "_parsePropertyPath", "parts", "join", "invariant", "str", "Object", "entries", "find", "label", "tag", "valueType", "Number", "array", "QueryDSL", "Parser", "configure", "strict"]
-}