@dxos/echo 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/dist/lib/neutral/chunk-O6BH7EPN.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/common/types/entity.ts", "../../../src/internal/Annotation/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Hidden slot on a static `Type.Type` entity that holds the source Effect\n * Schema. `Type.getSchema(...)` reads this for static types; persisted types\n * rebuild from `jsonSchema` instead. Stored as a string key for declaration\n * portability (see KindId comment above).\n */\nexport const StaticTypeSchemaSlot = '~@dxos/echo/Type.StaticSchema' as const;\nexport type StaticTypeSchemaSlot = typeof StaticTypeSchemaSlot;\n\n/**\n * Read the hidden `StaticTypeSchemaSlot` off any value that may carry one.\n * Returns `undefined` for raw schemas (no slot) and non-object inputs.\n * Single point-of-cast for the slot lookup.\n */\nexport const getStaticTypeSchema = (value: unknown): Schema.Schema.AnyNoContext | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [StaticTypeSchemaSlot]?: Schema.Schema.AnyNoContext })[StaticTypeSchemaSlot];\n};\n\n/**\n * Read the `[SchemaKindId]` brand off a value. Returns `undefined` for raw\n * schemas (which don't carry the brand on their static type) and non-object\n * inputs. Single point-of-cast for the brand lookup.\n */\nexport const getSchemaKind = (value: unknown): EntityKind | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [SchemaKindId]?: EntityKind })[SchemaKindId];\n};\n\n/**\n * Read the `[KindId]` brand off a value. Returns `undefined` for raw schemas\n * and non-object inputs. Companion to {@link getSchemaKind}.\n */\nexport const getEntityKindBrand = (value: unknown): EntityKind | undefined => {\n  if (value == null || typeof value !== 'object') {\n    return undefined;\n  }\n  return (value as { [KindId]?: EntityKind })[KindId];\n};\n\n/**\n * Phantom string key on `Type<A>` entities that carries the instance type `A`.\n * Lets internal helpers (`makeObject`, `createObject`, etc.) pattern-match the\n * instance type from an entity input without importing from the top-level\n * `Type` module. Mirrors `Type.InstancePhantomId` (declared in `Type.ts`).\n *\n * Stored as a string key so declarations remain portable across packages\n * (see KindId comment above).\n */\nexport const InstancePhantomId = '~@dxos/echo/Type.Instance' as const;\nexport type InstancePhantomId = typeof InstancePhantomId;\n\n/**\n * Nominal brand carried by the well-known \"any object\" / \"any relation\"\n * schemas (`Obj.Unknown`, `Relation.Unknown`). The brand lets `Ref.Ref`,\n * `Filter.type`, and `Query.type` accept these schemas in addition to\n * `Type.Type` entities, without opening the door to arbitrary raw schemas.\n *\n * Stored as a string key so declarations remain portable across packages\n * (see KindId comment above).\n */\nexport const UnknownTypeSchemaBrandId = '~@dxos/echo/UnknownTypeSchemaBrand' as const;\nexport type UnknownTypeSchemaBrandId = typeof UnknownTypeSchemaBrandId;\n\n/**\n * Schema-side companion to `Type.Type` entities for the \"any object\" /\n * \"any relation\" cases. Branded so `Ref.Ref` / `Filter.type` / `Query.type`\n * can pattern-match on it; arbitrary `Schema.Schema` values do not satisfy\n * this shape.\n */\nexport interface UnknownTypeSchema<A, K extends EntityKind> extends Schema.Schema<A, any, never> {\n  readonly [UnknownTypeSchemaBrandId]: K;\n}\n\n/**\n * Kinds of entities stored in ECHO: objects, relations, and types.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n  Type = 'type',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'org.dxos.schema.anyObject';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../common/types';\n\nexport interface AnnotationHelper<T> {\n  /**\n   * Get the annotation value from an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — to read an annotation off a `Type.Type`\n   * entity, unwrap it first with `Type.getSchema(entity)`. This keeps the\n   * annotation pipeline single-shaped and forces annotations to live on the\n   * source schema, not on the post-construction Type entity.\n   */\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  /**\n   * Get the annotation value from the AST.\n   */\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  /**\n   * Set the annotation on an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — annotations must be applied to the\n   * source schema BEFORE wrapping it with `Type.makeObject` / `Type.makeRelation`.\n   * In a pipe, place every `Annotation.X.set(...)` before the `Type.make...` step.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\n/**\n * Note: only for system annotations.\n */\n// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.\n// TODO(dmaretskyi): REconcile with Annotation.make.\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S): S =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj: Record<string, unknown> = {\n    $id: options.identifier ?? DXN.make(options.typename, options.version),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  };\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AASvB,IAAMC,uBAAuB;AAQ7B,IAAMC,sBAAsB,CAACC,UAAAA;AAClC,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAAkEF,oBAAAA;AAC5E;AAOO,IAAMI,gBAAgB,CAACF,UAAAA;AAC5B,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAA0CJ,YAAAA;AACpD;AAMO,IAAMO,qBAAqB,CAACH,UAAAA;AACjC,MAAIA,SAAS,QAAQ,OAAOA,UAAU,UAAU;AAC9C,WAAOC;EACT;AACA,SAAQD,MAAoCL,MAAAA;AAC9C;AAWO,IAAMS,oBAAoB;AAY1B,IAAMC,2BAA2B;AAgBjC,IAAKC,aAAAA,0BAAAA,aAAAA;;;;SAAAA;;AAML,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC9HlC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAiCb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAA+B;IACnCC,KAAKR,QAAQS,cAAcC,IAAIC,KAAKX,QAAQY,UAAUZ,QAAQa,OAAO;IACrEC,YAAYd,QAAQG;IACpBU,SAASb,QAAQa;IACjBD,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEa,MAAMf,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAES,MAAMf,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "StaticTypeSchemaSlot", "getStaticTypeSchema", "value", "undefined", "getSchemaKind", "getEntityKindBrand", "InstancePhantomId", "UnknownTypeSchemaBrandId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "make", "typename", "version", "entityKind", "$ref"]
+}

package/dist/lib/neutral/{chunk-Q7ZL2P5H.mjs → chunk-OIYW7R2G.mjs}

@@ -1,27 +1,25 @@
 import {
   Feed,
-  getQueueDxn
-} from "./chunk-ZFACXBY6.mjs";
+  getQueueUri
+} from "./chunk-BDQGMDIX.mjs";
 import {
   everything,
   is,
   props,
   type
-} from "./chunk-APJKDGFL.mjs";
+} from "./chunk-ZACMEAYV.mjs";
 import {
-  getDXN,
   getTypename,
+  getURI,
   instanceOf
-} from "./chunk-J54QMAKF.mjs";
+} from "./chunk-Q5FKCVBC.mjs";
 import {
   prettyQuery
-} from "./chunk-G54OX4IX.mjs";
+} from "./chunk-OYUG4FHF.mjs";
 import {
+  getTypeURIFromSpecifier,
   isDatabase
-} from "./chunk-I2DARWPX.mjs";
-import {
-  getTypeDXNFromSpecifier
-} from "./chunk-TNBK56IN.mjs";
+} from "./chunk-H26LSXVJ.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -68,12 +66,12 @@ var QueryClass = class _QueryClass {
     });
   }
   referencedBy(target, key) {
-    const dxn = target !== void 0 ? getTypeDXNFromSpecifier(target) : null;
+    const uri = target !== void 0 ? getTypeURIFromSpecifier(target) : null;
     return new _QueryClass({
       type: "incoming-references",
       anchor: this.ast,
       property: key ?? null,
-      typename: dxn?.toString() ?? null
+      typename: uri ?? null
     });
   }
   sourceOf(relation, predicates) {
@@ -134,7 +132,18 @@ var QueryClass = class _QueryClass {
       limit
     });
   }
-  from(arg, options) {
+  from(...args) {
+    if (args.length > 1 && args.every(_isRawScope)) {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scopes: args
+        }
+      });
+    }
+    const [arg, options] = args;
     if (arg == null) {
       throw new TypeError('Query.from() requires a valid data source argument (database, feed, query, scope, or "all-accessible-spaces").');
     }
@@ -154,21 +163,29 @@ var QueryClass = class _QueryClass {
         query: this.ast,
         from: {
           _tag: "scope",
-          scope: {
-            ...options?.includeFeeds ? {
-              allFeedsFromSpaces: true
-            } : {}
-          }
+          scopes: []
         }
       });
     }
-    if (_isScope(arg)) {
+    if (Array.isArray(arg) && arg.every(_isRawScope)) {
       return new _QueryClass({
         type: "from",
         query: this.ast,
         from: {
           _tag: "scope",
-          scope: arg
+          scopes: arg
+        }
+      });
+    }
+    if (_isRawScope(arg)) {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scopes: [
+            arg
+          ]
         }
       });
     }
@@ -182,12 +199,13 @@ var QueryClass = class _QueryClass {
         query: this.ast,
         from: {
           _tag: "scope",
-          scope: {
-            spaceIds: databases.map((db) => db.spaceId),
+          scopes: databases.map((db) => ({
+            _tag: "space",
+            spaceId: db.spaceId,
             ...options?.includeFeeds ? {
-              allFeedsFromSpaces: true
+              includeAllFeeds: true
             } : {}
-          }
+          }))
         }
       });
     }
@@ -206,21 +224,22 @@ var QueryClass = class _QueryClass {
       }
     }
     const feedItems = items;
-    const feedDXNs = feedItems.map((feed) => {
-      const dxn = getQueueDxn(feed);
-      if (!dxn) {
-        throw new TypeError(`Query.from() expects persisted Feed objects with a queue DXN; got feed without a space (id=${getDXN(feed).toString()}).`);
+    const feedScopes = feedItems.map((feed) => {
+      const uri = getQueueUri(feed);
+      if (!uri) {
+        throw new TypeError(`Query.from() expects persisted Feed objects with a queue URI; got feed without a space (id=${getURI(feed)}).`);
       }
-      return dxn.toString();
+      return {
+        _tag: "feed",
+        feedUri: String(uri)
+      };
     });
     return new _QueryClass({
       type: "from",
       query: this.ast,
       from: {
         _tag: "scope",
-        scope: {
-          feeds: feedDXNs
-        }
+        scopes: feedScopes
       }
     });
   }
@@ -263,10 +282,10 @@ var select = (filter) => {
     filter: filter.ast
   });
 };
-var type2 = (schema, predicates) => {
+var type2 = (type3, predicates) => {
   return new QueryClass({
     type: "select",
-    filter: type(schema, predicates).ast
+    filter: type(type3, predicates).ast
   });
 };
 var all = (...queries) => {
@@ -285,24 +304,21 @@ var without = (source, exclude) => {
     exclude: exclude.ast
   });
 };
-var from = (source, options) => {
+var from = (...args) => {
   const baseQuery = {
     type: "select",
     filter: everything().ast
   };
   const wrapper = new QueryClass(baseQuery);
-  return wrapper.from(source, options);
+  return wrapper.from(...args);
 };
-var SCOPE_KEYS = /* @__PURE__ */ new Set([
-  "spaceIds",
-  "feeds",
-  "allFeedsFromSpaces"
+var SCOPE_TAGS = /* @__PURE__ */ new Set([
+  "space",
+  "feed",
+  "registry"
 ]);
-var _isScope = (value) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  return Object.keys(value).every((key) => SCOPE_KEYS.has(key));
+var _isRawScope = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "_tag" in value && typeof value._tag === "string" && SCOPE_TAGS.has(value._tag);
 };
 var pretty = (query) => prettyQuery(query.ast);
 
@@ -317,4 +333,4 @@ export {
   pretty,
   Query_exports
 };
-//# sourceMappingURL=chunk-Q7ZL2P5H.mjs.map
+//# sourceMappingURL=chunk-OIYW7R2G.mjs.map

package/dist/lib/neutral/chunk-OIYW7R2G.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Query.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as EffectArray from 'effect/Array';\nimport type * as Schema from 'effect/Schema';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nimport type * as Collection from './Collection';\nimport * as Database from './Database';\nimport type * as Dataset from './Dataset';\nimport * as Feed from './Feed';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Order from './Order';\nimport type * as Ref from './Ref';\nimport type * as Relation from './Relation';\n// eslint-disable-next-line @dxos/rules/import-as-namespace\nimport type * as Type$ from './Type';\nimport type * as View from './View';\n\n// TODO(dmaretskyi): Split up into interfaces for objects and relations so they can have separate verbs.\n// TODO(dmaretskyi): Undirected relation traversals.\n// TODO(wittjosiah): Make Filter & Query pipeable.\n\n/**\n * All property paths inside T that are references.\n */\n// TODO(dmaretskyi): Filter only properties that are references (or optional references, or unions that include references).\ntype RefPropKey<T> = keyof T & string;\n\n// TODO(burdon): Narrow T to Entity.Unknown?\nexport interface Query<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Query': { value: T };\n\n  ast: QueryAST.Query;\n\n  /**\n   * Filter the current selection based on a filter.\n   * @param filter - Filter to select the objects.\n   * @returns Query for the selected objects.\n   */\n  'select'(filter: Filter.Filter<T>): Query<T>;\n  'select'(props: Filter.Props<T>): Query<T>;\n\n  /**\n   * Traverse an outgoing reference.\n   * @param key - Property path inside T that is a reference or optional reference.\n   * @returns Query for the target of the reference.\n   */\n  'reference'<K extends RefPropKey<T>>(\n    key: K,\n  ): Query<\n    T[K] extends Ref.Unknown\n      ? Ref.Target<T[K]>\n      : T[K] extends Ref.Unknown | undefined\n        ? Ref.Target<Exclude<T[K], undefined>>\n        : never\n  >;\n\n  /**\n   * Find objects referencing this object.\n   * @param target - Schema of the referencing object. If not provided, matches any type.\n   * @param key - Property path inside the referencing object that is a reference. If not provided, matches any property.\n   * @returns Query for the referencing objects.\n   */\n  // TODO(dmaretskyi): any way to enforce `Ref.Target<Schema.Schema.Type<S>[key]> == T`?\n  // TODO(dmaretskyi): Ability to go through arrays of references.\n  'referencedBy'<S extends Type$.AnyEntity>(\n    target: S | string,\n    key: RefPropKey<Type$.InstanceType<S>>,\n  ): Query<Type$.InstanceType<S>>;\n  'referencedBy'<S extends Type$.AnyEntity>(target: S | string): Query<Type$.InstanceType<S>>;\n  'referencedBy'(): Query<any>;\n\n  /**\n   * Find relations where this object is the source.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  'sourceOf'<R extends Type$.AnyRelation>(\n    relation?: R | string,\n    predicates?: Filter.Props<Type$.InstanceType<R>>,\n  ): Query<Type$.InstanceType<R>>;\n\n  /**\n   * Find relations where this object is the target.\n   * @returns Query for the relation objects.\n   * @param relation - Type entity of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  'targetOf'<R extends Type$.AnyRelation>(\n    relation?: R | string,\n    predicates?: Filter.Props<Type$.InstanceType<R>>,\n  ): Query<Type$.InstanceType<R>>;\n\n  /**\n   * For a query for relations, get the source objects.\n   * @returns Query for the source objects.\n   */\n  'source'(): Query<Relation.SourceOf<T>>;\n\n  /**\n   * For a query for relations, get the target objects.\n   * @returns Query for the target objects.\n   */\n  'target'(): Query<Relation.TargetOf<T>>;\n\n  /**\n   * Get the parent object of the current selection.\n   * @returns Query for the parent objects.\n   */\n  'parent'(): Query<any>;\n\n  /**\n   * Get all child objects of the current selection.\n   * @returns Query for the child objects.\n   */\n  'children'(): Query<any>;\n\n  /**\n   * Order the query results.\n   * Orders are specified in priority order. The first order will be applied first, etc.\n   * @param order - Order to sort the results.\n   * @returns Query for the ordered results.\n   */\n  'orderBy'(...order: EffectArray.NonEmptyArray<Order.Order<T>>): Query<T>;\n\n  /**\n   * Limit the number of results.\n   * @param limit - Maximum number of results to return.\n   * @returns Query for the limited results.\n   */\n  'limit'(limit: number): Query<T>;\n\n  /**\n   * Query from selected databases only.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from(db);\n   * ```\n   *\n   * @param options.includeFeeds [false] - Whether to include feeds in the query. Default is to query from automerge documents only.\n   */\n  'from'(database: Database.Database | Database.Database[], options?: { includeFeeds?: boolean }): Query<T>;\n\n  /**\n   * Query from selected feeds only.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from(feed);\n   * ```\n   *\n   */\n  'from'(feeds: Feed.Feed | Feed.Feed[]): Query<T>;\n\n  /**\n   * Query from all accessible spaces.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from('all-accessible-spaces');\n   * ```\n   *\n   * @param options.includeFeeds [false] - Whether to include feeds in the query. Default is to query from automerge documents only.\n   */\n  'from'(allSpaces: 'all-accessible-spaces', options?: { includeFeeds?: boolean }): Query<T>;\n\n  /**\n   * Query from a dataset.\n   * Currently only feeds are supported.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.type(Person).from(feed);\n   * ```\n   */\n  'from'(dataset: Dataset.Dataset): Query<T>;\n\n  /**\n   * Query from the results of another query.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.props({ foo: 'foo' })).from(Query.select(Filter.type(Contact)).reference('org'));\n   * ```\n   */\n  'from'(query: Any): Query<T>;\n\n  /**\n   * Query from one or more raw scopes.\n   *\n   * Use the {@link Scope} constructors rather than raw tagged objects:\n   *\n   * ```ts\n   * Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry());\n   * ```\n   */\n  'from'(...scopes: QueryAST.Scope[]): Query<T>;\n\n  /**\n   * Query from a raw scope or array of scopes.\n   */\n  'from'(scope: QueryAST.Scope | QueryAST.Scope[]): Query<T>;\n\n  /**\n   * Add options to a query.\n   */\n  'options'(options: QueryAST.QueryOptions): Query<T>;\n\n  /**\n   * Attach a diagnostic label for logs and tooling (execution semantics unchanged).\n   */\n  'debugLabel'(label: string): Query<T>;\n}\n\nexport type Any = Query<any>;\n\nexport type Type<Q extends Any> = Q extends Query<infer T> ? T : never;\n\nclass QueryClass implements Any {\n  private static 'variance': Any['~Query'] = {} as Any['~Query'];\n\n  constructor(public readonly ast: QueryAST.Query) {}\n\n  '~Query' = QueryClass.variance;\n\n  select(filter: Filter.Any | Filter.Props<any>): Any {\n    if (Filter.is(filter)) {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: filter.ast,\n      });\n    } else {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: Filter.props(filter).ast,\n      });\n    }\n  }\n\n  reference(key: string): Any {\n    return new QueryClass({\n      type: 'reference-traversal',\n      anchor: this.ast,\n      property: key,\n    });\n  }\n\n  referencedBy(target?: Type$.AnyEntity | string, key?: string): Any {\n    const uri = target !== undefined ? internal.getTypeURIFromSpecifier(target) : null;\n    return new QueryClass({\n      type: 'incoming-references',\n      anchor: this.ast,\n      property: key ?? null,\n      typename: uri ?? null,\n    });\n  }\n\n  sourceOf(relation?: Type$.AnyRelation | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'outgoing',\n      filter: relation !== undefined ? Filter.type(relation, predicates).ast : undefined,\n    });\n  }\n\n  targetOf(relation?: Type$.AnyRelation | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'incoming',\n      filter: relation !== undefined ? Filter.type(relation, predicates).ast : undefined,\n    });\n  }\n\n  source(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'source',\n    });\n  }\n\n  target(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'target',\n    });\n  }\n\n  parent(): Any {\n    return new QueryClass({\n      type: 'hierarchy-traversal',\n      anchor: this.ast,\n      direction: 'to-parent',\n    });\n  }\n\n  children(): Any {\n    return new QueryClass({\n      type: 'hierarchy-traversal',\n      anchor: this.ast,\n      direction: 'to-children',\n    });\n  }\n\n  orderBy(...order: Order.Order<any>[]): Any {\n    return new QueryClass({\n      type: 'order',\n      query: this.ast,\n      order: order.map((o) => o.ast),\n    });\n  }\n\n  limit(limit: number): Any {\n    return new QueryClass({\n      type: 'limit',\n      query: this.ast,\n      limit,\n    });\n  }\n\n  from(\n    ...args:\n      | [\n          (\n            | Database.Database\n            | Database.Database[]\n            | Feed.Feed\n            | Feed.Feed[]\n            | Collection.Collection\n            | View.View\n            | Any\n            | QueryAST.Scope\n            | QueryAST.Scope[]\n            | 'all-accessible-spaces'\n          ),\n          { includeFeeds?: boolean }?,\n        ]\n      | QueryAST.Scope[]\n  ): Any {\n    // Variadic raw scopes: `.from(Scope.space(), Scope.registry())`.\n    if (args.length > 1 && args.every(_isRawScope)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'scope', scopes: args as QueryAST.Scope[] },\n      });\n    }\n\n    const [arg, options] = args as [\n      (\n        | Database.Database\n        | Database.Database[]\n        | Feed.Feed\n        | Feed.Feed[]\n        | Collection.Collection\n        | View.View\n        | Any\n        | QueryAST.Scope\n        | QueryAST.Scope[]\n        | 'all-accessible-spaces'\n      ),\n      { includeFeeds?: boolean }?,\n    ];\n    if (arg == null) {\n      throw new TypeError(\n        'Query.from() requires a valid data source argument (database, feed, query, scope, or \"all-accessible-spaces\").',\n      );\n    }\n\n    if (is(arg)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'query', query: arg.ast },\n      });\n    }\n\n    if (arg === 'all-accessible-spaces') {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'scope', scopes: [] },\n      });\n    }\n\n    // Raw scope(s): tagged union objects with _tag 'space' | 'feed' | 'registry'.\n    if (Array.isArray(arg) && arg.every(_isRawScope)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'scope', scopes: arg as QueryAST.Scope[] },\n      });\n    }\n    if (_isRawScope(arg)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'scope', scopes: [arg] },\n      });\n    }\n\n    const items = Array.isArray(arg) ? arg : [arg];\n\n    if (items.length > 0 && Database.isDatabase(items[0])) {\n      const databases = items as Database.Database[];\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: {\n          _tag: 'scope',\n          scopes: databases.map((db) => ({\n            _tag: 'space' as const,\n            spaceId: db.spaceId,\n            ...(options?.includeFeeds ? { includeAllFeeds: true } : {}),\n          })),\n        },\n      });\n    }\n\n    if (items.length > 0) {\n      const typename = Obj.getTypename(items[0] as Obj.Unknown);\n      // TODO(dmaretskyi): Support querying from views.\n      if (typename === 'org.dxos.type.view') {\n        throw new Error('Query.from(view) is not yet supported.');\n      }\n      // TODO(dmaretskyi): Support querying from collections.\n      if (typename === 'org.dxos.type.collection') {\n        throw new Error('Query.from(collection) is not yet supported.');\n      }\n      // Validate that the items are Feed.Feed instances.\n      for (const item of items) {\n        if (!Obj.instanceOf(Feed.Feed, item)) {\n          throw new TypeError(\n            `Query.from() expects Feed objects (org.dxos.type.feed), but received an object with typename '${typename ?? 'unknown'}'.`,\n          );\n        }\n      }\n    }\n\n    const feedItems = items as Feed.Feed[];\n    const feedScopes = feedItems.map((feed) => {\n      const uri = Feed.getQueueUri(feed);\n      if (!uri) {\n        throw new TypeError(\n          `Query.from() expects persisted Feed objects with a queue URI; got feed without a space (id=${Obj.getURI(feed)}).`,\n        );\n      }\n      return { _tag: 'feed' as const, feedUri: String(uri) };\n    });\n    return new QueryClass({\n      type: 'from',\n      query: this.ast,\n      from: { _tag: 'scope', scopes: feedScopes },\n    });\n  }\n\n  options(options: QueryAST.QueryOptions): Any {\n    return new QueryClass({\n      type: 'options',\n      query: this.ast,\n      options,\n    });\n  }\n\n  debugLabel(label: string): Any {\n    if (this.ast.type === 'options') {\n      return new QueryClass({\n        type: 'options',\n        query: this.ast.query,\n        options: { ...this.ast.options, debugLabel: label },\n      });\n    }\n    return new QueryClass({\n      type: 'options',\n      query: this.ast,\n      options: { debugLabel: label },\n    });\n  }\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Query' in value;\n};\n\n/** Construct a query from an ast. */\nexport const fromAst = (ast: QueryAST.Query): Any => {\n  return new QueryClass(ast);\n};\n\n/**\n * Select objects based on a filter.\n * @param filter - Filter to select the objects.\n * @returns Query for the selected objects.\n */\nexport const select = <F extends Filter.Any>(filter: F): Query<Filter.Type<F>> => {\n  return new QueryClass({\n    type: 'select',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Query for objects of a given schema.\n * @param schema - Schema of the objects.\n * @param predicates - Predicates to filter the objects.\n * @returns Query for the objects.\n *\n * Shorthand for: `Query.select(Filter.type(schema, predicates))`.\n */\nexport const type: {\n  <T extends Type$.AnyEntity>(type: T, predicates?: Filter.Props<Type$.InstanceType<T>>): Query<Type$.InstanceType<T>>;\n  // Brand-narrowed schema overload — only well-known unknown schemas pass.\n  <S extends internal.UnknownTypeSchema<any, any>>(\n    schema: S,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n  <S extends Schema.Union<readonly Schema.Schema.AnyNoContext[]>>(\n    union: S,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n  (schema: string, predicates?: Filter.Props<unknown>): Query<any>;\n} = (type: Type$.AnyEntity | string, predicates?: Filter.Props<unknown>): Any => {\n  return new QueryClass({\n    type: 'select',\n    filter: Filter.type(type, predicates).ast,\n  });\n};\n\n/**\n * Combine results of multiple queries.\n * @param queries - Queries to combine.\n * @returns Query for the combined results.\n */\n// TODO(dmaretskyi): Rename to `combine` or `union`.\nexport const all = (...queries: Any[]): Any => {\n  if (queries.length === 0) {\n    throw new TypeError(\n      'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',\n    );\n  }\n  return new QueryClass({\n    type: 'union',\n    queries: queries.map((q) => q.ast),\n  });\n};\n\n/**\n * Subtract one query from another.\n * @param source - Query to subtract from.\n * @param exclude - Query to subtract.\n * @returns Query for the results of the source query minus the results of the exclude query.\n */\nexport const without = <T>(source: Query<T>, exclude: Query<T>): Query<T> => {\n  return new QueryClass({\n    type: 'set-difference',\n    source: source.ast,\n    exclude: exclude.ast,\n  });\n};\n\n/**\n * Create a query scoped to a data source.\n * The returned query selects everything from the source; chain `.select()` to narrow results.\n *\n * @param source - Data source: database, feed, 'all-accessible-spaces', or another query.\n * @returns Query scoped to the given source.\n */\nexport const from = (\n  ...args:\n    | [\n        (\n          | Database.Database\n          | Database.Database[]\n          | Feed.Feed\n          | Feed.Feed[]\n          | Any\n          | QueryAST.Scope\n          | QueryAST.Scope[]\n          | 'all-accessible-spaces'\n        ),\n        { includeFeeds?: boolean }?,\n      ]\n    | QueryAST.Scope[]\n): Any => {\n  const baseQuery: QueryAST.Query = {\n    type: 'select',\n    filter: Filter.everything().ast,\n  };\n  const wrapper = new QueryClass(baseQuery);\n  return (wrapper.from as (...args: unknown[]) => Any)(...args);\n};\n\nconst SCOPE_TAGS = new Set<string>(['space', 'feed', 'registry']);\n\n/** Detect a raw Scope tagged-union object. */\nconst _isRawScope = (value: unknown): value is QueryAST.Scope => {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    !Array.isArray(value) &&\n    '_tag' in value &&\n    typeof value._tag === 'string' &&\n    SCOPE_TAGS.has(value._tag)\n  );\n};\n\n/**\n * Returns a human-readable string representation of a Query AST.\n */\nexport const pretty = (query: Any): string => internal.prettyQuery(query.ast);\n"],
+  "mappings": "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",
+  "names": ["is", "type", "QueryClass", "ast", "variance", "select", "filter", "is", "type", "selection", "props", "reference", "key", "anchor", "property", "referencedBy", "target", "uri", "undefined", "getTypeURIFromSpecifier", "typename", "sourceOf", "relation", "predicates", "direction", "targetOf", "source", "parent", "children", "orderBy", "order", "query", "map", "o", "limit", "from", "args", "length", "every", "_isRawScope", "_tag", "scopes", "arg", "options", "TypeError", "Array", "isArray", "items", "isDatabase", "databases", "db", "spaceId", "includeFeeds", "includeAllFeeds", "getTypename", "Error", "item", "instanceOf", "Feed", "feedItems", "feedScopes", "feed", "getQueueUri", "getURI", "feedUri", "String", "debugLabel", "label", "value", "fromAst", "all", "queries", "q", "without", "exclude", "baseQuery", "everything", "wrapper", "SCOPE_TAGS", "Set", "has", "pretty", "prettyQuery"]
+}