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

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Query.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\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 (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 === 'dxos.org/type/View') {\n        throw new Error('Query.from(view) is not yet supported.');\n      }\n      // TODO(dmaretskyi): Support querying from collections.\n      if (typename === 'dxos.org/type/Collection') {\n        throw new Error('Query.from(collection) is not yet supported.');\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 = (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"],
+  "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", "_tag", "scope", "includeFeeds", "allQueuesFromSpaces", "_isScope", "items", "Array", "isArray", "length", "isDatabase", "databases", "spaceIds", "db", "spaceId", "getTypename", "Error", "feeds", "queueDxns", "flatMap", "feed", "getQueueDxn", "queues", "value", "fromAst", "schema", "all", "queries", "TypeError", "q", "without", "exclude", "baseQuery", "everything", "wrapper", "SCOPE_KEYS", "Set", "Object", "keys", "every", "has"]
+}

package/dist/lib/neutral/chunk-BRJSLACP.mjs

@@ -0,0 +1,152 @@
+import {
+  select
+} from "./chunk-AQP4QKYP.mjs";
+import {
+  Feed
+} from "./chunk-GFNCSK7F.mjs";
+import {
+  object
+} from "./chunk-T4MPQJ7X.mjs";
+import {
+  nothing
+} from "./chunk-ALOGSVBP.mjs";
+import {
+  Ref
+} from "./chunk-QXF3LGN2.mjs";
+import {
+  Unknown,
+  instanceOf,
+  make
+} from "./chunk-KGV3QIRX.mjs";
+import {
+  JsonSchemaType
+} from "./chunk-PP4DNUZU.mjs";
+import {
+  FormInputAnnotation,
+  SystemTypeAnnotation
+} from "./chunk-F7KMHDPJ.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/index.ts
+import { QueryAST as QueryAST2 } from "@dxos/echo-protocol";
+import { DXN } from "@dxos/keys";
+
+// src/Hypergraph.ts
+var Hypergraph_exports = {};
+
+// src/Collection.ts
+var Collection_exports = {};
+__export(Collection_exports, {
+  Collection: () => Collection,
+  isCollection: () => isCollection,
+  make: () => make2
+});
+import * as Schema from "effect/Schema";
+var Collection = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  objects: Schema.Array(Ref(Unknown)).pipe(FormInputAnnotation.set(false))
+}).pipe(object({
+  typename: "dxos.org/type/Collection",
+  version: "0.1.0"
+}));
+var make2 = (props = {}) => make(Collection, {
+  objects: [],
+  ...props
+});
+var isCollection = instanceOf(Collection);
+
+// src/View.ts
+var View_exports = {};
+__export(View_exports, {
+  FieldSchema: () => FieldSchema,
+  KeyValueProps: () => KeyValueProps,
+  Projection: () => Projection,
+  View: () => View,
+  createFieldId: () => createFieldId,
+  make: () => make3
+});
+import * as Schema2 from "effect/Schema";
+import { QueryAST } from "@dxos/echo-protocol";
+import { JsonPath } from "@dxos/effect";
+import { PublicKey } from "@dxos/keys";
+var FieldSchema = Schema2.Struct({
+  id: Schema2.String,
+  path: JsonPath,
+  visible: Schema2.optional(Schema2.Boolean),
+  // TODO(wittjosiah): Presentation-specific?
+  referencePath: Schema2.optional(JsonPath)
+});
+var KeyValueProps = Schema2.Record({
+  key: Schema2.String,
+  value: Schema2.Any
+});
+var createFieldId = () => PublicKey.random().truncate();
+var Projection = Schema2.Struct({
+  /**
+  * Optional schema override used to customize the underlying schema.
+  */
+  schema: JsonSchemaType.pipe(Schema2.optional),
+  /**
+  * UX metadata associated with displayed fields (in table, form, etc.)
+  */
+  // TODO(wittjosiah): Should this just be an array of JsonPath?
+  fields: Schema2.Array(FieldSchema),
+  /**
+  * The id for the field used to pivot the view.
+  * E.g., the field to use for kanban columns or the field to use for map coordinates.
+  */
+  pivotFieldId: Schema2.String.pipe(Schema2.optional)
+});
+var ViewSchema = Schema2.Struct({
+  /**
+  * Query used to retrieve data.
+  * Can be a user-provided query grammar string or a query AST.
+  */
+  query: Schema2.Struct({
+    raw: Schema2.optional(Schema2.String),
+    ast: QueryAST.Query
+  }),
+  /**
+  * Projection of the data returned from the query.
+  */
+  projection: Projection
+}).pipe(object({
+  typename: "dxos.org/type/View",
+  version: "0.5.0"
+}), SystemTypeAnnotation.set(true));
+var View = ViewSchema;
+var make3 = (props) => {
+  return make(View, {
+    query: {
+      ast: select(nothing()).ast
+    },
+    projection: {
+      fields: []
+    },
+    ...props
+  });
+};
+
+// src/Dataset.ts
+var Dataset_exports = {};
+__export(Dataset_exports, {
+  Dataset: () => Dataset,
+  isDataset: () => isDataset
+});
+import { pipe } from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as Schema3 from "effect/Schema";
+var Dataset = Schema3.Union(Feed, Collection, View);
+var isDataset = pipe(instanceOf(Feed), Predicate.or(instanceOf(Collection)), Predicate.or(instanceOf(View)));
+
+export {
+  Hypergraph_exports,
+  Collection_exports,
+  View_exports,
+  Dataset_exports,
+  QueryAST2 as QueryAST,
+  DXN
+};
+//# sourceMappingURL=chunk-BRJSLACP.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/index.ts", "../../../src/Hypergraph.ts", "../../../src/Collection.ts", "../../../src/View.ts", "../../../src/Dataset.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport { QueryAST } from '@dxos/echo-protocol';\n// TODO(wittjosiah): Refactor DXN to not use statics similar to Query.\nexport { DXN } from '@dxos/keys';\n\nexport * as Annotation from './Annotation';\nexport * as Database from './Database';\nexport * as Entity from './Entity';\nexport * as Err from './Err';\nexport * as Feed from './Feed';\nexport * as Filter from './Filter';\nexport * as Format from './Format';\nexport * as Hypergraph from './Hypergraph';\nexport * as JsonSchema from './JsonSchema';\nexport * as Key from './Key';\nexport * as Obj from './Obj';\nexport * as Order from './Order';\nexport * as Query from './Query';\nexport * as QueryResult from './QueryResult';\nexport * as Ref from './Ref';\nexport * as Relation from './Relation';\nexport * as SchemaRegistry from './SchemaRegistry';\nexport * as Tag from './Tag';\nexport * as Type from './Type';\nexport * as Collection from './Collection';\nexport * as View from './View';\nexport * as Dataset from './Dataset';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { type DXN } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport type * as internal from './internal';\nimport type * as Key from './Key';\nimport type * as Ref from './Ref';\nimport type * as SchemaRegistry from './SchemaRegistry';\n\n/**\n * Resolution context.\n * Affects how non-absolute DXNs are resolved.\n */\nexport interface RefResolutionContext {\n  /**\n   * Space that the resolution is happening from.\n   */\n  space?: Key.SpaceId;\n\n  /**\n   * Queue that the resolution is happening from.\n   * This queue will be searched first, and then the space it belongs to.\n   */\n  queue?: DXN;\n}\n\nexport interface RefResolverOptions {\n  /**\n   * Resolution context.\n   * Affects how non-absolute DXNs are resolved.\n   */\n  context?: RefResolutionContext;\n\n  /**\n   * Middleware to change the resolved object before returning it.\n   * @deprecated On track to be removed.\n   */\n  middleware?: (obj: internal.AnyProperties) => internal.AnyProperties;\n}\n\n/**\n *\n */\n// TODO(burdon): Comment required.\nexport interface Hypergraph extends Database.Queryable {\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  /**\n   * Query objects.\n   */\n  query: Database.QueryFn;\n\n  /**\n   * Creates a reference to an existing object in the database.\n   *\n   * NOTE: The reference may be dangling if the object is not present in the database.\n   * NOTE: Difference from `Ref.fromDXN`\n   * `Ref.fromDXN(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.\n   * `db.makeRef(dxn)` is preferable in cases with access to the database.\n   */\n  makeRef<T extends Entity.Unknown = Entity.Unknown>(dxn: DXN): Ref.Ref<T>;\n\n  /**\n   * @param hostDb Host database for reference resolution.\n   * @param middleware Called with the loaded object. The caller may change the object.\n   * @returns Result of `onLoad`.\n   */\n  // TODO(dmaretskyi): Restructure API: Remove middleware.\n  createRefResolver(options: RefResolverOptions): Ref.Resolver;\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Ref from './Ref';\nimport * as Type from './Type';\n\n/**\n * A an ordered set of objects.\n */\nexport const Collection = Schema.Struct({\n  name: Schema.String.pipe(Schema.optional),\n  objects: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(internal.FormInputAnnotation.set(false)),\n}).pipe(\n  Type.object({\n    typename: 'dxos.org/type/Collection',\n    version: '0.1.0',\n  }),\n);\n\nexport interface Collection extends Schema.Schema.Type<typeof Collection> {}\n\nexport const make = (props: Partial<Obj.MakeProps<typeof Collection>> = {}): Collection =>\n  Obj.make(Collection, { objects: [], ...props });\n\nexport const isCollection: (value: unknown) => value is Collection = Obj.instanceOf(Collection);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { QueryAST } from '@dxos/echo-protocol';\nimport { JsonPath } from '@dxos/effect';\nimport { PublicKey } from '@dxos/keys';\n\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Query from './Query';\nimport * as Type from './Type';\n\n/**\n * Stored field metadata (e.g., for UX).\n */\nexport const FieldSchema = Schema.Struct({\n  id: Schema.String,\n  path: JsonPath,\n  visible: Schema.optional(Schema.Boolean),\n\n  // TODO(wittjosiah): Presentation-specific?\n  referencePath: Schema.optional(JsonPath),\n});\n\nexport type FieldType = Schema.Schema.Type<typeof FieldSchema>;\n\nexport const KeyValueProps = Schema.Record({ key: Schema.String, value: Schema.Any });\n\nexport const createFieldId = () => PublicKey.random().truncate();\n\nexport const Projection = Schema.Struct({\n  /**\n   * Optional schema override used to customize the underlying schema.\n   */\n  schema: internal.JsonSchemaType.pipe(Schema.optional),\n\n  /**\n   * UX metadata associated with displayed fields (in table, form, etc.)\n   */\n  // TODO(wittjosiah): Should this just be an array of JsonPath?\n  fields: Schema.Array(FieldSchema),\n\n  /**\n   * The id for the field used to pivot the view.\n   * E.g., the field to use for kanban columns or the field to use for map coordinates.\n   */\n  pivotFieldId: Schema.String.pipe(Schema.optional),\n});\n\nexport type Projection = Schema.Schema.Type<typeof Projection>;\n\n/**\n * Views are generated or user-defined projections of a schema's properties.\n * They are used to configure the visual representation of the data.\n */\nconst ViewSchema = Schema.Struct({\n  /**\n   * Query used to retrieve data.\n   * Can be a user-provided query grammar string or a query AST.\n   */\n  query: Schema.Struct({\n    raw: Schema.optional(Schema.String),\n    ast: QueryAST.Query,\n  }),\n\n  /**\n   * Projection of the data returned from the query.\n   */\n  projection: Projection,\n}).pipe(\n  Type.object({\n    typename: 'dxos.org/type/View',\n    version: '0.5.0',\n  }),\n  internal.SystemTypeAnnotation.set(true),\n);\n\nexport interface View extends Schema.Schema.Type<typeof ViewSchema> {}\n\n/**\n * View instance type.\n */\n// NOTE: This interface is explicitly defined rather than derived from the schema to avoid\n//   TypeScript \"cannot be named\" portability errors. The schema contains QueryAST.Query which\n//   references internal @dxos/echo-protocol module paths. Without this explicit interface,\n//   any schema using Ref.Ref(View) would inherit the non-portable type and fail to compile.\n// TODO(wittjosiah): Find a better solution that doesn't require manually keeping the interface in sync.\nexport const View: Type.Obj<View> = ViewSchema as any;\n\nexport const make = (props: Partial<Obj.MakeProps<typeof View>>): View => {\n  return Obj.make(View, {\n    query: { ast: Query.select(Filter.nothing()).ast },\n    projection: { fields: [] },\n    ...props,\n  });\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { pipe } from 'effect/Function';\nimport * as Predicate from 'effect/Predicate';\nimport * as Schema from 'effect/Schema';\n\nimport * as Collection from './Collection';\nimport * as Feed from './Feed';\nimport * as Obj from './Obj';\nimport * as View from './View';\n\n/**\n * Abstart set of objects, represented by a view, feed, or collection.\n */\nexport const Dataset = Schema.Union(Feed.Feed, Collection.Collection, View.View);\nexport type Dataset = Feed.Feed | Collection.Collection | View.View;\n\nexport const isDataset: (value: unknown) => value is Dataset = pipe(\n  Obj.instanceOf(Feed.Feed),\n  Predicate.or(Obj.instanceOf(Collection.Collection)),\n  Predicate.or(Obj.instanceOf(View.View)),\n);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,SAASA,YAAAA,iBAAgB;AAEzB,SAASC,WAAW;;;ACNpB;;;ACAA;;;;cAAAC;;AAIA,YAAYC,YAAY;AAUjB,IAAMC,aAAoBC,cAAO;EACtCC,MAAaC,cAAOC,KAAYC,eAAQ;EACxCC,SAAgBC,aAAUC,IAAQC,OAAO,CAAA,EAAGL,KAAcM,oBAAoBC,IAAI,KAAA,CAAA;AACpF,CAAA,EAAGP,KACIQ,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,CAAA;AAKK,IAAMC,QAAO,CAACC,QAAmD,CAAC,MACnED,KAAKf,YAAY;EAAEM,SAAS,CAAA;EAAI,GAAGU;AAAM,CAAA;AAExC,IAAMC,eAA4DC,WAAWlB,UAAAA;;;AC7BpF;;;;;;;cAAAmB;;AAIA,YAAYC,aAAY;AAExB,SAASC,gBAAgB;AACzB,SAASC,gBAAgB;AACzB,SAASC,iBAAiB;AAWnB,IAAMC,cAAqBC,eAAO;EACvCC,IAAWC;EACXC,MAAMC;EACNC,SAAgBC,iBAAgBC,eAAO;;EAGvCC,eAAsBF,iBAASF,QAAAA;AACjC,CAAA;AAIO,IAAMK,gBAAuBC,eAAO;EAAEC,KAAYT;EAAQU,OAAcC;AAAI,CAAA;AAE5E,IAAMC,gBAAgB,MAAMC,UAAUC,OAAM,EAAGC,SAAQ;AAEvD,IAAMC,aAAoBlB,eAAO;;;;EAItCmB,QAAiBC,eAAeC,KAAYf,gBAAQ;;;;;EAMpDgB,QAAeC,cAAMxB,WAAAA;;;;;EAMrByB,cAAqBtB,eAAOmB,KAAYf,gBAAQ;AAClD,CAAA;AAQA,IAAMmB,aAAoBzB,eAAO;;;;;EAK/B0B,OAAc1B,eAAO;IACnB2B,KAAYrB,iBAAgBJ,cAAM;IAClC0B,KAAKC,SAASC;EAChB,CAAA;;;;EAKAC,YAAYb;AACd,CAAA,EAAGG,KACIW,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,qBAAqBC,IAAI,IAAA,CAAA;AAa7B,IAAMC,OAAuBZ;AAE7B,IAAMa,QAAO,CAACC,UAAAA;AACnB,SAAWD,KAAKD,MAAM;IACpBX,OAAO;MAAEE,KAAWY,OAAcC,QAAO,CAAA,EAAIb;IAAI;IACjDG,YAAY;MAAET,QAAQ,CAAA;IAAG;IACzB,GAAGiB;EACL,CAAA;AACF;;;ACnGA;;;;;AAIA,SAASG,YAAY;AACrB,YAAYC,eAAe;AAC3B,YAAYC,aAAY;AAUjB,IAAMC,UAAiBC,cAAWC,MAAiBC,YAAiBC,IAAI;AAGxE,IAAMC,YAAkDC,KACzDC,WAAgBL,IAAI,GACdM,aAAOD,WAAsBJ,UAAU,CAAA,GACvCK,aAAOD,WAAgBH,IAAI,CAAA,CAAA;",
+  "names": ["QueryAST", "DXN", "make", "Schema", "Collection", "Struct", "name", "String", "pipe", "optional", "objects", "Array", "Ref", "Unknown", "FormInputAnnotation", "set", "object", "typename", "version", "make", "props", "isCollection", "instanceOf", "make", "Schema", "QueryAST", "JsonPath", "PublicKey", "FieldSchema", "Struct", "id", "String", "path", "JsonPath", "visible", "optional", "Boolean", "referencePath", "KeyValueProps", "Record", "key", "value", "Any", "createFieldId", "PublicKey", "random", "truncate", "Projection", "schema", "JsonSchemaType", "pipe", "fields", "Array", "pivotFieldId", "ViewSchema", "query", "raw", "ast", "QueryAST", "Query", "projection", "object", "typename", "version", "SystemTypeAnnotation", "set", "View", "make", "props", "select", "nothing", "pipe", "Predicate", "Schema", "Dataset", "Union", "Feed", "Collection", "View", "isDataset", "pipe", "instanceOf", "or"]
+}

package/dist/lib/neutral/chunk-DZQSL6RW.mjs

@@ -0,0 +1,73 @@
+import {
+  Currency,
+  CurrencyAnnotationId,
+  DecimalPrecision,
+  Email,
+  Format,
+  FormatAnnotation,
+  FormatAnnotationId,
+  FormatEnums,
+  Formula,
+  GeoLocation,
+  GeoPoint,
+  Hostname,
+  JSON,
+  Markdown,
+  OptionsAnnotation,
+  OptionsAnnotationId,
+  PropertyKind,
+  Regex,
+  SelectOption,
+  Text,
+  TypeEnum,
+  TypeFormat,
+  URL,
+  UUID,
+  formatToType,
+  getFormatAnnotation,
+  getOptionsAnnotation,
+  getTypeEnum,
+  typeToFormat
+} from "./chunk-M2KVTHZM.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Format.ts
+var Format_exports = {};
+__export(Format_exports, {
+  Currency: () => Currency,
+  CurrencyAnnotationId: () => CurrencyAnnotationId,
+  DecimalPrecision: () => DecimalPrecision,
+  Email: () => Email,
+  Format: () => Format,
+  FormatAnnotation: () => FormatAnnotation,
+  FormatAnnotationId: () => FormatAnnotationId,
+  FormatEnums: () => FormatEnums,
+  Formula: () => Formula,
+  GeoLocation: () => GeoLocation,
+  GeoPoint: () => GeoPoint,
+  Hostname: () => Hostname,
+  JSON: () => JSON,
+  Markdown: () => Markdown,
+  OptionsAnnotation: () => OptionsAnnotation,
+  OptionsAnnotationId: () => OptionsAnnotationId,
+  PropertyKind: () => PropertyKind,
+  Regex: () => Regex,
+  SelectOption: () => SelectOption,
+  Text: () => Text,
+  TypeEnum: () => TypeEnum,
+  TypeFormat: () => TypeFormat,
+  URL: () => URL,
+  UUID: () => UUID,
+  formatToType: () => formatToType,
+  getFormatAnnotation: () => getFormatAnnotation,
+  getOptionsAnnotation: () => getOptionsAnnotation,
+  getTypeEnum: () => getTypeEnum,
+  typeToFormat: () => typeToFormat
+});
+
+export {
+  Format_exports
+};
+//# sourceMappingURL=chunk-DZQSL6RW.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Format.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as internal from './internal';\n\nexport * from './internal/formats';\n\nexport type Format = internal.TypeFormat;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+  "names": []
+}

package/dist/lib/neutral/chunk-F7KMHDPJ.mjs

@@ -0,0 +1,327 @@
+import {
+  EntityKind,
+  createAnnotationHelper
+} from "./chunk-4KG6IGL4.mjs";
+
+// src/internal/types/typename.ts
+var ATTR_TYPE = "@type";
+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];
+  }
+};
+var setSchema = (obj, schema) => {
+  Object.defineProperty(obj, SchemaId, {
+    value: schema,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+
+// src/internal/annotations/annotations.ts
+import * as Function from "effect/Function";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+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 FIELD_PATH_ANNOTATION = "path";
+var FieldPath = (path) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
+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");
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return DXN.parse(id);
+  }
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (!objectAnnotation) {
+    return void 0;
+  }
+  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);
+};
+var getTypeDXNFromSpecifier = (input) => {
+  if (Schema.isSchema(input)) {
+    return getSchemaDXN(input) ?? raise(new TypeError("Schema has no DXN"));
+  } else {
+    assertArgument(typeof input === "string", "input");
+    assertArgument(!input.startsWith("dxn:"), "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 VersionSchema = Schema.String.pipe(Schema.pattern(/^\d+.\d+.\d+$/)).annotations({
+  description: "Semantic version format: `major.minor.patch`",
+  example: "1.0.0"
+});
+var TypeMeta = Schema.Struct({
+  typename: TypenameSchema,
+  version: VersionSchema
+});
+var TypeAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Type");
+var TypeAnnotation = Schema.extend(TypeMeta, Schema.Struct({
+  kind: Schema.Enums(EntityKind),
+  /**
+   * If this is a relation, the schema of the source object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  sourceSchema: Schema.optional(DXN.Schema),
+  /**
+   * If this is a relation, the schema of the target object.
+   * Must be present if entity kind is {@link EntityKind.Relation}.
+   */
+  targetSchema: Schema.optional(DXN.Schema)
+}));
+var getTypeAnnotation = (schema) => {
+  assertArgument(schema != null && schema.ast != null, "schema", "invalid schema");
+  return Function.flow(SchemaAST.getAnnotation(TypeAnnotationId), Option.getOrElse(() => void 0))(schema.ast);
+};
+var getEntityKind = (schema) => getTypeAnnotation(schema)?.kind;
+var getSchemaTypename = (schema) => getTypeAnnotation(schema)?.typename;
+var getSchemaVersion = (schema) => getTypeAnnotation(schema)?.version;
+var getTypename = (obj) => {
+  const schema = getSchema(obj);
+  if (schema != null) {
+    return getSchemaTypename(schema);
+  } else {
+    const type = getTypeDXN(obj);
+    return type?.asTypeDXN()?.type;
+  }
+};
+var setTypename = (obj, typename) => {
+  invariant(typename instanceof DXN, "Invalid type.", {
+    F: __dxlog_file,
+    L: 198,
+    S: void 0,
+    A: [
+      "typename instanceof DXN",
+      "'Invalid type.'"
+    ]
+  });
+  Object.defineProperty(obj, TypeId, {
+    value: typename,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+};
+var getTypeDXN = (obj) => {
+  if (!obj) {
+    return void 0;
+  }
+  const type = obj[TypeId];
+  if (!type) {
+    return void 0;
+  }
+  invariant(type instanceof DXN, "Invalid object.", {
+    F: __dxlog_file,
+    L: 225,
+    S: void 0,
+    A: [
+      "type instanceof DXN",
+      "'Invalid object.'"
+    ]
+  });
+  return type;
+};
+var isInstanceOf = (schema, object) => {
+  if (object == null) {
+    return false;
+  }
+  const schemaDXN = getSchemaDXN(schema);
+  if (!schemaDXN) {
+    throw new Error("Schema must have an object annotation.");
+  }
+  const type = getTypeDXN(object);
+  if (type && DXN.equals(type, schemaDXN)) {
+    return true;
+  }
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+  const typeDXN = schemaDXN.asTypeDXN();
+  if (!typeDXN) {
+    return false;
+  }
+  return typeDXN.type === typename;
+};
+var PropertyMetaAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/PropertyMeta");
+var PropertyMeta = (name, value) => {
+  return (self) => {
+    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId];
+    return self.annotations({
+      [PropertyMetaAnnotationId]: {
+        ...existingMeta,
+        [name]: value
+      }
+    });
+  };
+};
+var getPropertyMetaAnnotation = (prop, name) => Function.pipe(SchemaAST.getAnnotation(PropertyMetaAnnotationId)(prop.type), Option.map((meta) => meta[name]), Option.getOrElse(() => void 0));
+var ReferenceAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/Reference");
+var ReferenceAnnotation = createAnnotationHelper(ReferenceAnnotationId);
+var SchemaMetaSymbol = /* @__PURE__ */ Symbol.for("@dxos/schema/SchemaMeta");
+var SystemTypeAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/SystemType");
+var SystemTypeAnnotation = createAnnotationHelper(SystemTypeAnnotationId);
+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(() => [
+    "name"
+  ]));
+  for (const accessor of annotation) {
+    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 "number":
+      case "boolean":
+      case "bigint":
+      case "symbol":
+        return value.toString();
+      case "undefined":
+      case "object":
+      case "function":
+        continue;
+    }
+  }
+  return void 0;
+};
+var setLabelWithSchema = (schema, object, label) => {
+  const annotation = LabelAnnotation.get(schema).pipe(Option.map((field) => field[0]), Option.getOrElse(() => "name"));
+  object[annotation] = label;
+};
+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"));
+  assertArgument(typeof accessor === "string", "accessor", "Description annotation must be a string");
+  const value = getField(object, accessor);
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "bigint":
+    case "symbol":
+      return value.toString();
+    case "undefined":
+    case "object":
+    case "function":
+    default:
+      return void 0;
+  }
+};
+var setDescriptionWithSchema = (schema, object, description) => {
+  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => "description"));
+  object[accessor] = description;
+};
+var FormInputAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormInput");
+var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
+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-zA-Z0-9]+\.[a-zA-Z.]+\/[a-zA-Z/]+/.test(props.id), "id", "Annotation id must be in the FQN format (dxos.org/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: "dxos.org/annotation/Icon",
+  schema: IconAnnotationSchema
+});
+
+export {
+  ATTR_TYPE,
+  TypeId,
+  SchemaId,
+  ATTR_PARENT,
+  ParentId,
+  getSchema,
+  setSchema,
+  FIELD_PATH_ANNOTATION,
+  FieldPath,
+  TypeIdentifierAnnotationId,
+  getTypeIdentifierAnnotation,
+  getSchemaDXN,
+  getTypeDXNFromSpecifier,
+  TypenameSchema,
+  VersionSchema,
+  TypeMeta,
+  TypeAnnotationId,
+  TypeAnnotation,
+  getTypeAnnotation,
+  getEntityKind,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypename,
+  setTypename,
+  getTypeDXN,
+  isInstanceOf,
+  PropertyMetaAnnotationId,
+  PropertyMeta,
+  getPropertyMetaAnnotation,
+  ReferenceAnnotationId,
+  ReferenceAnnotation,
+  SchemaMetaSymbol,
+  SystemTypeAnnotationId,
+  SystemTypeAnnotation,
+  LabelAnnotationId,
+  LabelAnnotation,
+  getLabelWithSchema,
+  setLabelWithSchema,
+  DescriptionAnnotationId,
+  DescriptionAnnotation,
+  getDescriptionWithSchema,
+  setDescriptionWithSchema,
+  FormInputAnnotationId,
+  FormInputAnnotation,
+  FieldLookupAnnotationId,
+  GeneratorAnnotationId,
+  GeneratorAnnotation,
+  makeUserAnnotation,
+  IconAnnotation
+};
+//# sourceMappingURL=chunk-F7KMHDPJ.mjs.map