@dxos/echo 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/dist/lib/neutral/Type.mjs

@@ -0,0 +1,37 @@
+import {
+  PersistentType,
+  RuntimeType,
+  getDXN,
+  getMeta,
+  getTypename,
+  getVersion,
+  isMutable,
+  isObjectSchema,
+  isRelationSchema,
+  object,
+  relation
+} from "./chunk-UPWIIW2V.mjs";
+import "./chunk-FW7UJX25.mjs";
+import "./chunk-R72KFH2X.mjs";
+import "./chunk-FNEFSO2C.mjs";
+import "./chunk-DQYLD2RB.mjs";
+import "./chunk-QWAOTFCY.mjs";
+import "./chunk-EBVB5NOH.mjs";
+import "./chunk-6URFBQJH.mjs";
+import "./chunk-TBKX6JQO.mjs";
+import "./chunk-UBEZSGXY.mjs";
+import "./chunk-J5LGTIGS.mjs";
+export {
+  PersistentType,
+  RuntimeType,
+  getDXN,
+  getMeta,
+  getTypename,
+  getVersion,
+  isMutable,
+  isObjectSchema,
+  isRelationSchema,
+  object,
+  relation
+};
+//# sourceMappingURL=Type.mjs.map

package/dist/lib/{browser/chunk-XDIUHAAX.mjs → neutral/chunk-46QNGNTY.mjs}

@@ -1,17 +1,19 @@
-import "@dxos/node-std/globals";
+import {
+  RefArray
+} from "./chunk-R72KFH2X.mjs";
 import {
   Ref,
-  RefArray,
   getSchemaReference
-} from "./chunk-BJPE6CIC.mjs";
+} from "./chunk-QWAOTFCY.mjs";
 import {
   __export
-} from "./chunk-CGS2ULMK.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/Ref.ts
 var Ref_exports = {};
 __export(Ref_exports, {
   Array: () => Array,
+  Ref: () => Ref2,
   fromDXN: () => fromDXN,
   isRef: () => isRef,
   isRefType: () => isRefType,
@@ -19,6 +21,7 @@ __export(Ref_exports, {
 });
 import * as Option from "effect/Option";
 import * as SchemaAST from "effect/SchemaAST";
+var Ref2 = Ref;
 var Array = RefArray;
 var isRef = Ref.isRef;
 var make = Ref.make;
@@ -31,6 +34,7 @@ var isRefType = (ast) => {
 };
 
 export {
+  Ref2 as Ref,
   Array,
   isRef,
   make,
@@ -38,4 +42,4 @@ export {
   isRefType,
   Ref_exports
 };
-//# sourceMappingURL=chunk-XDIUHAAX.mjs.map
+//# sourceMappingURL=chunk-46QNGNTY.mjs.map

package/dist/lib/neutral/chunk-46QNGNTY.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport type * as Entity from './Entity';\nimport * as refInternal from './internal/Ref';\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Obj from './Obj';\n\n/**\n * Instance type for a reference.\n *\n * Reference can point to any object or relation.\n * References are lazy loaded.\n *\n * `ref.dxn` is the DXN of the referenced object.\n *\n * @example\n * ```ts\n * const taskRef: Ref<Task> = Ref.make(task);\n *\n * await taskRef.load(); // Returns Promise<Task>\n * yield* Database.load(taskRef); // Effectful version.\n *\n * database.makeRef(dxn); // Create a ref from a DXN.\n * ```\n */\nexport type Ref<T> = refInternal.Ref<T>;\nexport type Unknown = refInternal.Ref<Obj.Unknown>;\n\n/**\n * Factory function to create a Ref schema for the given target schema.\n * Use this in schema definitions to declare reference fields.\n *\n * @example\n * ```ts\n * const Task = Schema.Struct({\n *   assignee: Ref.Ref(Person),  // Creates a Ref schema\n * }).pipe(Type.object({ typename: 'Task', version: '0.1.0' }));\n * ```\n */\nexport const Ref: <S extends Schema.Schema.Any>(schema: S) => RefSchema<Schema.Schema.Type<S>> = refInternal.Ref;\n\nexport const Array = refInternal.RefArray;\n\n/**\n * TypeScript type for a Ref schema.\n * This is the type of the SCHEMA itself, not the runtime ref instance.\n * For the instance type, use `Ref.Ref<T>` from the Ref module.\n *\n * @example\n * ```ts\n * // Schema type annotation (rarely needed, usually inferred):\n * const refSchema: Ref.RefSchema<typeof Task> = Ref.Ref(Task);\n *\n * // Instance type annotation (use Ref.Ref instead):\n * const refInstance: Ref.Ref<Task> = Ref.make(task);\n * ```\n */\n// TODO(dmaretskyi): Investigate if we can remove this type.\n//                   Post DX-836 it will become just `Schema.Schema<Ref.Ref<T>>`.\n//                   NOTE: This could be Type.Ref<T> instead, but since it going to be removed, it's better to keep it here, self-contained.\nexport interface RefSchema<T extends Entity.Unknown> extends refInternal.RefSchema<T> {}\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Unknown> = R extends refInternal.Ref<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = refInternal.RefResolver;\n\nexport const isRef: (value: unknown) => value is Unknown = refInternal.Ref.isRef;\n\nexport const make = refInternal.Ref.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept DXN.\nexport const fromDXN = refInternal.Ref.fromDXN;\n\n// TODO(wittjosiah): Factor out?\nexport const isRefType = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation<JsonSchema.JsonSchema>(ast, SchemaAST.JSONSchemaAnnotationId).pipe(\n    Option.flatMap((jsonSchema) => ('$id' in jsonSchema ? Option.some(jsonSchema) : Option.none())),\n    Option.flatMap((jsonSchema) => {\n      const { typename } = refInternal.getSchemaReference(jsonSchema) ?? {};\n      return typename ? Option.some(true) : Option.some(false);\n    }),\n    Option.getOrElse(() => false),\n  );\n};\n"],
+  "mappings": ";;;;;;;;;;;;AAAA;;;aAAAA;EAAA;;;;;AAMA,YAAYC,YAAY;AAExB,YAAYC,eAAe;AAuCpB,IAAMC,OAAgGA;AAEtG,IAAMC,QAAoBC;AA+B1B,IAAMC,QAA0DH,IAAIG;AAEpE,IAAMC,OAAmBJ,IAAII;AAG7B,IAAMC,UAAsBL,IAAIK;AAGhC,IAAMC,YAAY,CAACC,QAAAA;AACxB,SAAiBC,wBAAqCD,KAAeE,gCAAsB,EAAEC,KACpFC,eAAQ,CAACC,eAAgB,SAASA,aAAoBC,YAAKD,UAAAA,IAAqBE,YAAI,CAAA,GACpFH,eAAQ,CAACC,eAAAA;AACd,UAAM,EAAEG,SAAQ,IAAiBC,mBAAmBJ,UAAAA,KAAe,CAAC;AACpE,WAAOG,WAAkBF,YAAK,IAAA,IAAeA,YAAK,KAAA;EACpD,CAAA,GACOI,iBAAU,MAAM,KAAA,CAAA;AAE3B;",
+  "names": ["Ref", "Option", "SchemaAST", "Ref", "Array", "RefArray", "isRef", "make", "fromDXN", "isRefType", "ast", "getAnnotation", "JSONSchemaAnnotationId", "pipe", "flatMap", "jsonSchema", "some", "none", "typename", "getSchemaReference", "getOrElse"]
+}

package/dist/lib/neutral/chunk-5VKHCUDA.mjs

@@ -0,0 +1,299 @@
+import {
+  Feed,
+  getQueueDxn
+} from "./chunk-HBJ7JT5A.mjs";
+import {
+  everything,
+  is,
+  props,
+  type
+} from "./chunk-T2JOLN37.mjs";
+import {
+  getTypename,
+  instanceOf
+} from "./chunk-ZGVZNBBJ.mjs";
+import {
+  prettyQuery
+} from "./chunk-FW7UJX25.mjs";
+import {
+  isDatabase
+} from "./chunk-EBVB5NOH.mjs";
+import {
+  getTypeDXNFromSpecifier
+} from "./chunk-6URFBQJH.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Query.ts
+var Query_exports = {};
+__export(Query_exports, {
+  all: () => all,
+  from: () => from,
+  fromAst: () => fromAst,
+  is: () => is2,
+  pretty: () => pretty,
+  select: () => select,
+  type: () => type2,
+  without: () => without
+});
+var QueryClass = class _QueryClass {
+  ast;
+  static "variance" = {};
+  constructor(ast) {
+    this.ast = ast;
+  }
+  "~Query" = _QueryClass.variance;
+  select(filter) {
+    if (is(filter)) {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: filter.ast
+      });
+    } else {
+      return new _QueryClass({
+        type: "filter",
+        selection: this.ast,
+        filter: props(filter).ast
+      });
+    }
+  }
+  reference(key) {
+    return new _QueryClass({
+      type: "reference-traversal",
+      anchor: this.ast,
+      property: key
+    });
+  }
+  referencedBy(target, key) {
+    const dxn = target !== void 0 ? getTypeDXNFromSpecifier(target) : null;
+    return new _QueryClass({
+      type: "incoming-references",
+      anchor: this.ast,
+      property: key ?? null,
+      typename: dxn?.toString() ?? null
+    });
+  }
+  sourceOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "outgoing",
+      filter: relation !== void 0 ? type(relation, predicates).ast : void 0
+    });
+  }
+  targetOf(relation, predicates) {
+    return new _QueryClass({
+      type: "relation",
+      anchor: this.ast,
+      direction: "incoming",
+      filter: relation !== void 0 ? type(relation, predicates).ast : void 0
+    });
+  }
+  source() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "source"
+    });
+  }
+  target() {
+    return new _QueryClass({
+      type: "relation-traversal",
+      anchor: this.ast,
+      direction: "target"
+    });
+  }
+  parent() {
+    return new _QueryClass({
+      type: "hierarchy-traversal",
+      anchor: this.ast,
+      direction: "to-parent"
+    });
+  }
+  children() {
+    return new _QueryClass({
+      type: "hierarchy-traversal",
+      anchor: this.ast,
+      direction: "to-children"
+    });
+  }
+  orderBy(...order) {
+    return new _QueryClass({
+      type: "order",
+      query: this.ast,
+      order: order.map((o) => o.ast)
+    });
+  }
+  limit(limit) {
+    return new _QueryClass({
+      type: "limit",
+      query: this.ast,
+      limit
+    });
+  }
+  from(arg, options) {
+    if (arg == null) {
+      throw new TypeError('Query.from() requires a valid data source argument (database, feed, query, scope, or "all-accessible-spaces").');
+    }
+    if (is2(arg)) {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "query",
+          query: arg.ast
+        }
+      });
+    }
+    if (arg === "all-accessible-spaces") {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scope: {
+            ...options?.includeFeeds ? {
+              allQueuesFromSpaces: true
+            } : {}
+          }
+        }
+      });
+    }
+    if (_isScope(arg)) {
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scope: arg
+        }
+      });
+    }
+    const items = Array.isArray(arg) ? arg : [
+      arg
+    ];
+    if (items.length > 0 && isDatabase(items[0])) {
+      const databases = items;
+      return new _QueryClass({
+        type: "from",
+        query: this.ast,
+        from: {
+          _tag: "scope",
+          scope: {
+            spaceIds: databases.map((db) => db.spaceId),
+            ...options?.includeFeeds ? {
+              allQueuesFromSpaces: true
+            } : {}
+          }
+        }
+      });
+    }
+    if (items.length > 0) {
+      const typename = getTypename(items[0]);
+      if (typename === "org.dxos.type.view") {
+        throw new Error("Query.from(view) is not yet supported.");
+      }
+      if (typename === "org.dxos.type.collection") {
+        throw new Error("Query.from(collection) is not yet supported.");
+      }
+      for (const item of items) {
+        if (!instanceOf(Feed, item)) {
+          throw new TypeError(`Query.from() expects Feed objects (org.dxos.type.feed), but received an object with typename '${typename ?? "unknown"}'.`);
+        }
+      }
+    }
+    const feeds = items;
+    const queueDxns = feeds.flatMap((feed) => {
+      const dxn = getQueueDxn(feed);
+      return dxn ? [
+        dxn.toString()
+      ] : [];
+    });
+    return new _QueryClass({
+      type: "from",
+      query: this.ast,
+      from: {
+        _tag: "scope",
+        scope: {
+          queues: queueDxns
+        }
+      }
+    });
+  }
+  options(options) {
+    return new _QueryClass({
+      type: "options",
+      query: this.ast,
+      options
+    });
+  }
+};
+var is2 = (value) => {
+  return typeof value === "object" && value !== null && "~Query" in value;
+};
+var fromAst = (ast) => {
+  return new QueryClass(ast);
+};
+var select = (filter) => {
+  return new QueryClass({
+    type: "select",
+    filter: filter.ast
+  });
+};
+var type2 = (schema, predicates) => {
+  return new QueryClass({
+    type: "select",
+    filter: type(schema, predicates).ast
+  });
+};
+var all = (...queries) => {
+  if (queries.length === 0) {
+    throw new TypeError("Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())");
+  }
+  return new QueryClass({
+    type: "union",
+    queries: queries.map((q) => q.ast)
+  });
+};
+var without = (source, exclude) => {
+  return new QueryClass({
+    type: "set-difference",
+    source: source.ast,
+    exclude: exclude.ast
+  });
+};
+var from = (source, options) => {
+  const baseQuery = {
+    type: "select",
+    filter: everything().ast
+  };
+  const wrapper = new QueryClass(baseQuery);
+  return wrapper.from(source, options);
+};
+var SCOPE_KEYS = /* @__PURE__ */ new Set([
+  "spaceIds",
+  "queues",
+  "allQueuesFromSpaces"
+]);
+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 pretty = (query) => prettyQuery(query.ast);
+
+export {
+  is2 as is,
+  fromAst,
+  select,
+  type2 as type,
+  all,
+  without,
+  from,
+  pretty,
+  Query_exports
+};
+//# sourceMappingURL=chunk-5VKHCUDA.mjs.map

package/dist/lib/neutral/chunk-5VKHCUDA.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';\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 Schema.Schema.All>(\n    target: S | string,\n    key: RefPropKey<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n  'referencedBy'<S extends Schema.Schema.All>(target: S | string): Query<Schema.Schema.Type<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'<S extends Schema.Schema.All>(\n    relation?: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Find relations where this object is the target.\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  'targetOf'<S extends Schema.Schema.All>(\n    relation?: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\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 a raw scope specification.\n   */\n  'from'(scope: QueryAST.Scope): Query<T>;\n\n  /**\n   * Add options to a query.\n   */\n  'options'(options: QueryAST.QueryOptions): 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?: Schema.Schema.All | string, key?: string): Any {\n    const dxn = target !== undefined ? internal.getTypeDXNFromSpecifier(target) : null;\n    return new QueryClass({\n      type: 'incoming-references',\n      anchor: this.ast,\n      property: key ?? null,\n      typename: dxn?.toString() ?? null,\n    });\n  }\n\n  sourceOf(relation?: Schema.Schema.All | 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?: Schema.Schema.All | 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    arg:\n      | Database.Database\n      | Database.Database[]\n      | Feed.Feed\n      | Feed.Feed[]\n      | Collection.Collection\n      | View.View\n      | Any\n      | QueryAST.Scope\n      | 'all-accessible-spaces',\n    options?: { includeFeeds?: boolean },\n  ): Any {\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: {\n          _tag: 'scope',\n          scope: {\n            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),\n          },\n        },\n      });\n    }\n\n    if (_isScope(arg)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'scope', scope: 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          scope: {\n            spaceIds: databases.map((db) => db.spaceId),\n            ...(options?.includeFeeds ? { allQueuesFromSpaces: 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 feeds = items as Feed.Feed[];\n    const queueDxns = feeds.flatMap((feed) => {\n      const dxn = Feed.getQueueDxn(feed);\n      return dxn ? [dxn.toString()] : [];\n    });\n    return new QueryClass({\n      type: 'from',\n      query: this.ast,\n      from: {\n        _tag: 'scope',\n        scope: {\n          queues: queueDxns,\n        },\n      },\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\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  <S extends Schema.Schema.All>(\n    schema: 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} = (schema: Schema.Schema.All | string, predicates?: Filter.Props<unknown>): Any => {\n  return new QueryClass({\n    type: 'select',\n    filter: Filter.type(schema, 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  source:\n    | Database.Database\n    | Database.Database[]\n    | Feed.Feed\n    | Feed.Feed[]\n    | Any\n    | QueryAST.Scope\n    | 'all-accessible-spaces',\n  options?: { includeFeeds?: boolean },\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(source as any, options);\n};\n\nconst SCOPE_KEYS = new Set(['spaceIds', 'queues', 'allQueuesFromSpaces']);\n\n/** Detect a raw Scope object (plain object with only Scope-valid keys). */\nconst _isScope = (value: unknown): value is QueryAST.Scope => {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    return false;\n  }\n  return Object.keys(value).every((key) => SCOPE_KEYS.has(key));\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", "dxn", "undefined", "getTypeDXNFromSpecifier", "typename", "toString", "sourceOf", "relation", "predicates", "direction", "targetOf", "source", "parent", "children", "orderBy", "order", "query", "map", "o", "limit", "from", "arg", "options", "TypeError", "_tag", "scope", "includeFeeds", "allQueuesFromSpaces", "_isScope", "items", "Array", "isArray", "length", "isDatabase", "databases", "spaceIds", "db", "spaceId", "getTypename", "Error", "item", "instanceOf", "Feed", "feeds", "queueDxns", "flatMap", "feed", "getQueueDxn", "queues", "value", "fromAst", "schema", "all", "queries", "q", "without", "exclude", "baseQuery", "everything", "wrapper", "SCOPE_KEYS", "Set", "Object", "keys", "every", "has", "pretty", "prettyQuery"]
+}

package/dist/lib/{node-esm/chunk-YOLH5KS4.mjs → neutral/chunk-6URFBQJH.mjs}

@@ -1,13 +1,14 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
   EntityKind,
   createAnnotationHelper
-} from "./chunk-XHJRMQZD.mjs";
+} from "./chunk-TBKX6JQO.mjs";
 
-// src/internal/types/typename.ts
+// src/internal/common/types/typename.ts
 var ATTR_TYPE = "@type";
-var TypeId = Symbol.for("@dxos/echo/Type");
-var SchemaId = Symbol.for("@dxos/echo/Schema");
+var TypeId = /* @__PURE__ */ Symbol.for("@dxos/echo/Type");
+var SchemaId = /* @__PURE__ */ Symbol.for("@dxos/echo/Schema");
+var ATTR_PARENT = "@parent";
+var ParentId = /* @__PURE__ */ Symbol.for("@dxos/echo/Parent");
 var getSchema = (obj) => {
   if (obj) {
     return obj[SchemaId];
@@ -22,7 +23,7 @@ var setSchema = (obj, schema) => {
   });
 };
 
-// src/internal/annotations/annotations.ts
+// src/internal/Annotation/annotations.ts
 import * as Function from "effect/Function";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
@@ -31,10 +32,10 @@ import { raise } from "@dxos/debug";
 import { getField } from "@dxos/effect";
 import { assertArgument, invariant } from "@dxos/invariant";
 import { DXN } from "@dxos/keys";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/annotations/annotations.ts";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/Annotation/annotations.ts";
 var FIELD_PATH_ANNOTATION = "path";
 var FieldPath = (path) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
-var TypeIdentifierAnnotationId = Symbol.for("@dxos/schema/annotation/TypeIdentifier");
+var TypeIdentifierAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/TypeIdentifier");
 var getTypeIdentifierAnnotation = (schema) => Function.flow(SchemaAST.getAnnotation(TypeIdentifierAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
 var getSchemaDXN = (schema) => {
   assertArgument(Schema.isSchema(schema), "schema", "invalid schema");
@@ -57,9 +58,9 @@ var getTypeDXNFromSpecifier = (input) => {
     return DXN.fromTypename(input);
   }
 };
-var TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\w+\.[a-zA-Z]\w{1,}\/[\w/_-]+$/)).annotations({
-  description: "Fully qualified globally unique typename",
-  example: "dxos.org/type/Message"
+var TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z][a-zA-Z0-9]*(\.[a-zA-Z][a-zA-Z0-9-]*){2,}$/)).annotations({
+  description: "Fully qualified globally unique typename in reverse-DNS form.",
+  example: "org.dxos.type.message"
 });
 var VersionSchema = Schema.String.pipe(Schema.pattern(/^\d+.\d+.\d+$/)).annotations({
   description: "Semantic version format: `major.minor.patch`",
@@ -69,7 +70,7 @@ var TypeMeta = Schema.Struct({
   typename: TypenameSchema,
   version: VersionSchema
 });
-var TypeAnnotationId = Symbol.for("@dxos/schema/annotation/Type");
+var TypeAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Type");
 var TypeAnnotation = Schema.extend(TypeMeta, Schema.Struct({
   kind: Schema.Enums(EntityKind),
   /**
@@ -102,7 +103,7 @@ var getTypename = (obj) => {
 var setTypename = (obj, typename) => {
   invariant(typename instanceof DXN, "Invalid type.", {
     F: __dxlog_file,
-    L: 198,
+    L: 199,
     S: void 0,
     A: [
       "typename instanceof DXN",
@@ -126,7 +127,7 @@ var getTypeDXN = (obj) => {
   }
   invariant(type instanceof DXN, "Invalid object.", {
     F: __dxlog_file,
-    L: 225,
+    L: 226,
     S: void 0,
     A: [
       "type instanceof DXN",
@@ -157,7 +158,7 @@ var isInstanceOf = (schema, object) => {
   }
   return typeDXN.type === typename;
 };
-var PropertyMetaAnnotationId = Symbol.for("@dxos/schema/annotation/PropertyMeta");
+var PropertyMetaAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/PropertyMeta");
 var PropertyMeta = (name, value) => {
   return (self) => {
     const existingMeta = self.ast.annotations[PropertyMetaAnnotationId];
@@ -170,12 +171,12 @@ var PropertyMeta = (name, value) => {
   };
 };
 var getPropertyMetaAnnotation = (prop, name) => Function.pipe(SchemaAST.getAnnotation(PropertyMetaAnnotationId)(prop.type), Option.map((meta) => meta[name]), Option.getOrElse(() => void 0));
-var ReferenceAnnotationId = Symbol.for("@dxos/schema/annotation/Reference");
+var ReferenceAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Reference");
 var ReferenceAnnotation = createAnnotationHelper(ReferenceAnnotationId);
-var SchemaMetaSymbol = Symbol.for("@dxos/schema/SchemaMeta");
-var SystemTypeAnnotationId = Symbol.for("@dxos/schema/annotation/SystemType");
+var SchemaMetaSymbol = /* @__PURE__ */ Symbol.for("@dxos/schema/SchemaMeta");
+var SystemTypeAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/SystemType");
 var SystemTypeAnnotation = createAnnotationHelper(SystemTypeAnnotationId);
-var LabelAnnotationId = Symbol.for("@dxos/schema/annotation/Label");
+var LabelAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Label");
 var LabelAnnotation = createAnnotationHelper(LabelAnnotationId);
 var getLabelWithSchema = (schema, object) => {
   const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => [
@@ -185,7 +186,13 @@ var getLabelWithSchema = (schema, object) => {
     assertArgument(typeof accessor === "string", "accessor", "Label annotation must be a string or an array of strings");
     const value = getField(object, accessor);
     switch (typeof value) {
-      case "string":
+      case "string": {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+          return value;
+        }
+        continue;
+      }
       case "number":
       case "boolean":
       case "bigint":
@@ -203,7 +210,7 @@ var setLabelWithSchema = (schema, object, label) => {
   const annotation = LabelAnnotation.get(schema).pipe(Option.map((field) => field[0]), Option.getOrElse(() => "name"));
   object[annotation] = label;
 };
-var DescriptionAnnotationId = Symbol.for("@dxos/schema/annotation/Description");
+var DescriptionAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Description");
 var DescriptionAnnotation = createAnnotationHelper(DescriptionAnnotationId);
 var getDescriptionWithSchema = (schema, object) => {
   const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => "description"));
@@ -227,16 +234,81 @@ var setDescriptionWithSchema = (schema, object, description) => {
   const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => "description"));
   object[accessor] = description;
 };
-var FormInputAnnotationId = Symbol.for("@dxos/schema/annotation/FormInput");
+var FormInputAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormInput");
 var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
-var FieldLookupAnnotationId = Symbol.for("@dxos/schema/annotation/FieldLookup");
-var GeneratorAnnotationId = Symbol.for("@dxos/schema/annotation/Generator");
+var FieldLookupAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FieldLookup");
+var GeneratorAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Generator");
 var GeneratorAnnotation = createAnnotationHelper(GeneratorAnnotationId);
+var makeUserAnnotation = (props) => {
+  assertArgument(/^[a-z][a-z0-9]*(\.[a-z][a-z0-9-]*){2,}$/.test(props.id), "id", "Annotation id must be in the FQN format (org.dxos.annotation.example).");
+  const getFromAst = (ast) => SchemaAST.getAnnotation(PropertyMetaAnnotationId)(ast).pipe(Option.map((meta) => meta[props.id]), Option.map(Schema.decodeUnknownSync(props.schema)));
+  return {
+    get: (schema) => getFromAst(schema.ast),
+    getFromAst: (ast) => getFromAst(ast),
+    set: (value) => PropertyMeta(props.id, Schema.encodeSync(props.schema)(value))
+  };
+};
+var IconAnnotationSchema = Schema.Struct({
+  /**
+  * Phosphor icon name (e.g., 'ph--user--regular', 'ph--cube--regular', 'ph--link--regular ', etc.)
+  */
+  icon: Schema.String.pipe(Schema.pattern(/^ph--[a-z-]+--[a-z]+$/)),
+  /**
+  * Color name.
+  *
+  * List of colors:
+  *  - 'red'
+  *  - 'orange'
+  *  - 'amber'
+  *  - 'yellow'
+  *  - 'lime'
+  *  - 'green'
+  *  - 'emerald'
+  *  - 'teal'
+  *  - 'cyan'
+  *  - 'violet'
+  *  - 'purple'
+  *  - 'fuchsia'
+  *  - 'pink'
+  *  - 'rose'
+  */
+  hue: Schema.optional(Schema.String)
+});
+var IconAnnotation = makeUserAnnotation({
+  id: "org.dxos.annotation.icon",
+  schema: IconAnnotationSchema
+});
+var getLabel = (entity) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getLabelWithSchema(schema, entity);
+  }
+};
+var setLabel = (entity, label) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setLabelWithSchema(schema, entity, label);
+  }
+};
+var getDescription = (entity) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getDescriptionWithSchema(schema, entity);
+  }
+};
+var setDescription = (entity, description) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setDescriptionWithSchema(schema, entity, description);
+  }
+};
 
 export {
   ATTR_TYPE,
   TypeId,
   SchemaId,
+  ATTR_PARENT,
+  ParentId,
   getSchema,
   setSchema,
   FIELD_PATH_ANNOTATION,
@@ -278,6 +350,12 @@ export {
   FormInputAnnotation,
   FieldLookupAnnotationId,
   GeneratorAnnotationId,
-  GeneratorAnnotation
+  GeneratorAnnotation,
+  makeUserAnnotation,
+  IconAnnotation,
+  getLabel,
+  setLabel,
+  getDescription,
+  setDescription
 };
-//# sourceMappingURL=chunk-YOLH5KS4.mjs.map
+//# sourceMappingURL=chunk-6URFBQJH.mjs.map