@dxos/echo 0.9.1-main.c7dcc2e112 → 0.10.0

package/dist/lib/neutral/chunk-3KTE2Y7Q.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';\nimport { type URI } from '@dxos/keys';\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\ntype RefArrayElement<A> = A extends readonly (infer E)[] ? E : A extends (infer E)[] ? E : never;\n\n/** Target entity when traversing an outgoing ref or array-of-refs property. */\ntype ReferenceTraversalTarget<P> = P extends Ref.Unknown\n  ? Ref.Target<P>\n  : P extends Ref.Unknown | undefined\n    ? Ref.Target<Exclude<P, undefined>>\n    : RefArrayElement<P> extends Ref.Unknown\n      ? Ref.Target<RefArrayElement<P>>\n      : never;\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>>(key: K): Query<ReferenceTraversalTarget<T[K]>>;\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 | URI.URI,\n    key: RefPropKey<Type$.InstanceType<S>>,\n  ): Query<Type$.InstanceType<S>>;\n  'referencedBy'<S extends Type$.AnyEntity>(target: S | URI.URI): 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 | URI.URI,\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 | URI.URI,\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 | URI.URI, 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 | URI.URI, 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 | URI.URI, 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  (uri: URI.URI, predicates?: Filter.Props<unknown>): Query<any>;\n} = (type: Type$.AnyEntity | URI.URI, 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", "filter", "is", "type", "selection", "props", "key", "anchor", "property", "target", "uri", "undefined", "getTypeURIFromSpecifier", "typename", "relation", "predicates", "direction", "order", "query", "map", "o", "limit", "args", "length", "every", "_isRawScope", "from", "_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", "label", "debugLabel", "value", "fromAst", "select", "all", "queries", "q", "without", "source", "exclude", "baseQuery", "everything", "wrapper", "SCOPE_TAGS", "Set", "has", "pretty", "prettyQuery"]
+}

package/dist/lib/neutral/{chunk-WZ32BF53.mjs → chunk-3TN2VMI4.mjs}

@@ -3,10 +3,10 @@ import {
   KindId,
   createAnnotationHelper,
   getStaticTypeSchema
-} from "./chunk-O6BH7EPN.mjs";
+} from "./chunk-2ZHECXUR.mjs";
 import {
   EntityNotFoundError
-} from "./chunk-BBFJWWAV.mjs";
+} from "./chunk-TOCVVFK2.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -33,12 +33,10 @@ __export(Database_exports, {
   spaceId: () => spaceId
 });
 import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Effectable from "effect/Effectable";
+import * as Effect2 from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Option3 from "effect/Option";
 import * as Schema5 from "effect/Schema";
-import { EffectEx } from "@dxos/effect";
+import { EffectEx as EffectEx2 } from "@dxos/effect";
 import { invariant as invariant5 } from "@dxos/invariant";
 
 // src/internal/Entity/type-uri.ts
@@ -284,13 +282,18 @@ var getDescriptionWithSchema = (schema, object) => {
   }
 };
 var setDescriptionWithSchema = (schema, object, description) => {
-  const accessor = DescriptionAnnotation.get(schema).pipe(Option2.getOrElse(() => "description"));
-  object[accessor] = description;
+  const accessorOpt = DescriptionAnnotation.get(schema);
+  if (Option2.isNone(accessorOpt)) {
+    return;
+  }
+  object[accessorOpt.value] = description;
 };
 var FormInputAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormInput");
 var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
 var FormInlineAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormInline");
 var FormInlineAnnotation = createAnnotationHelper(FormInlineAnnotationId);
+var FormCreateAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormCreate");
+var FormCreateAnnotation = createAnnotationHelper(FormCreateAnnotationId);
 var FormOrderedAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/schema/annotation/FormOrdered");
 var FormOrderedAnnotation = createAnnotationHelper(FormOrderedAnnotationId);
 var FormLayoutAnnotationId = /* @__PURE__ */ Symbol.for("@dxos/react-ui-form/annotation/Layout");
@@ -489,7 +492,7 @@ var getTypeURIFromSpecifier = (input) => {
   if (Schema4.isSchema(input)) {
     return getSchemaURI(input) ?? raise(new TypeError("Schema has no URI"));
   }
-  if (typeof input === "object" && input !== null && KindId in input) {
+  if (input !== null && (typeof input === "object" || typeof input === "function") && KindId in input) {
     const schema = getStaticTypeSchema(input);
     if (schema != null) {
       const uri = getSchemaURI(schema);
@@ -522,6 +525,23 @@ var isInstanceOf = (schemaOrType, object) => {
   return parsed != null && DXN3.getName(parsed) === typename;
 };
 
+// src/internal/Query/query-result-effect.ts
+import * as Effect from "effect/Effect";
+import * as Effectable from "effect/Effectable";
+import * as Option3 from "effect/Option";
+import { EffectEx } from "@dxos/effect";
+var makeQueryResultEffect = (eff) => {
+  return {
+    run: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(() => result.run())),
+    first: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(async () => Option3.fromNullable(await result.firstOrUndefined()))),
+    // Effect internals: the result is itself an Effect, so it carries the commit prototype.
+    ...Effectable.CommitPrototype,
+    commit() {
+      return eff;
+    }
+  };
+};
+
 // src/Database.ts
 var __dxlog_file5 = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
 var TypeId2 = /* @__PURE__ */ Symbol.for("@dxos/echo/Database");
@@ -546,49 +566,38 @@ var makeService = (db) => {
 var layer = (db) => {
   return Layer.succeed(Service, makeService(db));
 };
-var spaceId = Effect.gen(function* () {
+var spaceId = Effect2.gen(function* () {
   const { db } = yield* Service;
   return db.spaceId;
 });
-var resolve = (ref, schema) => Effect.gen(function* () {
+var resolve = (ref, schema) => Effect2.gen(function* () {
   const { db } = yield* Service;
   const dxn = typeof ref === "string" ? ref : ref.uri;
-  const object = yield* EffectEx.promiseWithCauseCapture(() => db.graph.createRefResolver({
+  const object = yield* EffectEx2.promiseWithCauseCapture(() => db.graph.createRefResolver({
     context: {
       space: db.spaceId
     }
   }).resolveLegacy(dxn));
   if (!object) {
-    return yield* Effect.fail(new EntityNotFoundError(dxn));
+    return yield* Effect2.fail(new EntityNotFoundError(dxn));
   }
-  invariant5(!schema || isInstanceOf(schema, object), "Object type mismatch.", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 71, S: this, A: ["!schema || isInstanceOf(schema, object)", "'Object type mismatch.'"] });
+  invariant5(!schema || isInstanceOf(schema, object), "Object type mismatch.", { "~LogMeta": "~LogMeta", F: __dxlog_file5, L: 70, S: this, A: ["!schema || isInstanceOf(schema, object)", "'Object type mismatch.'"] });
   return object;
-}).pipe(Effect.withSpan("Database.resolve"));
-var load = Effect.fn("Database.load")(function* (ref) {
-  const object = yield* EffectEx.promiseWithCauseCapture(() => ref.tryLoad());
+}).pipe(Effect2.withSpan("Database.resolve"));
+var load = Effect2.fn("Database.load")(function* (ref) {
+  const object = yield* EffectEx2.promiseWithCauseCapture(() => ref.tryLoad());
   if (!object) {
-    return yield* Effect.fail(new EntityNotFoundError(ref.uri));
+    return yield* Effect2.fail(new EntityNotFoundError(ref.uri));
   }
   return object;
 });
-var add = (obj) => Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan("Database.add"));
-var addType = (type) => Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.addType(type)))).pipe(Effect.withSpan("Database.addType"));
-var remove = (obj) => Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan("Database.remove"));
-var appendToFeed = (feed, entities) => Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.appendToFeed(feed, entities)))).pipe(Effect.withSpan("Database.appendToFeed"));
-var deleteFromFeed = (feed, entities) => Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.deleteFromFeed(feed, entities)))).pipe(Effect.withSpan("Database.deleteFromFeed"));
-var flush = (opts) => Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.flush(opts)))).pipe(Effect.withSpan("Database.flush"));
-var query = (queryOrFilter) => Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Database.query"), makeQueryResultEffect);
-var makeQueryResultEffect = (eff) => {
-  return {
-    run: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(() => result.run())),
-    first: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(async () => Option3.fromNullable(await result.firstOrUndefined()))),
-    // Effect internals
-    ...Effectable.CommitPrototype,
-    commit() {
-      return eff;
-    }
-  };
-};
+var add = (obj) => Service.pipe(Effect2.map(({ db }) => db.add(obj))).pipe(Effect2.withSpan("Database.add"));
+var addType = (type) => Service.pipe(Effect2.flatMap(({ db }) => EffectEx2.promiseWithCauseCapture(() => db.addType(type)))).pipe(Effect2.withSpan("Database.addType"));
+var remove = (obj) => Service.pipe(Effect2.map(({ db }) => db.remove(obj))).pipe(Effect2.withSpan("Database.remove"));
+var appendToFeed = (feed, entities) => Service.pipe(Effect2.flatMap(({ db }) => EffectEx2.promiseWithCauseCapture(() => db.appendToFeed(feed, entities)))).pipe(Effect2.withSpan("Database.appendToFeed"));
+var deleteFromFeed = (feed, entities) => Service.pipe(Effect2.flatMap(({ db }) => EffectEx2.promiseWithCauseCapture(() => db.deleteFromFeed(feed, entities)))).pipe(Effect2.withSpan("Database.deleteFromFeed"));
+var flush = (opts) => Service.pipe(Effect2.flatMap(({ db }) => EffectEx2.promiseWithCauseCapture(() => db.flush(opts)))).pipe(Effect2.withSpan("Database.flush"));
+var query = (queryOrFilter) => Service.pipe(Effect2.map(({ db }) => db.query(queryOrFilter)), Effect2.withSpan("Database.query"), makeQueryResultEffect);
 
 export {
   Key,
@@ -656,6 +665,8 @@ export {
   FormInputAnnotation,
   FormInlineAnnotationId,
   FormInlineAnnotation,
+  FormCreateAnnotationId,
+  FormCreateAnnotation,
   FormOrderedAnnotationId,
   FormOrderedAnnotation,
   FormLayoutAnnotationId,
@@ -680,6 +691,7 @@ export {
   getDatabase,
   getTypeURIFromSpecifier,
   isInstanceOf,
+  makeQueryResultEffect,
   TypeId2,
   isDatabase,
   Database,
@@ -699,4 +711,4 @@ export {
   query,
   Database_exports
 };
-//# sourceMappingURL=chunk-WZ32BF53.mjs.map
+//# sourceMappingURL=chunk-3TN2VMI4.mjs.map

package/dist/lib/neutral/chunk-3TN2VMI4.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Database.ts", "../../../src/internal/Entity/type-uri.ts", "../../../src/internal/Annotation/annotations.ts", "../../../src/internal/common/types/model-symbols.ts", "../../../src/internal/common/types/typename.ts", "../../../src/internal/Annotation/dictionary.ts", "../../../src/internal/Entity/api.ts", "../../../src/internal/Entity/model.ts", "../../../src/internal/Entity/util.ts", "../../../src/internal/Query/query-result-effect.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Schema from 'effect/Schema';\n\nimport { EffectEx } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { type SpaceId, type URI } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport * as Err from './Err';\nimport type * as Feed from './Feed';\nimport type * as Filter from './Filter';\nimport type * as Hypergraph from './Hypergraph';\nimport { type AnyProperties, EntityKind, KindId } from './internal/common/types';\n// Deep import (not the `./internal/Entity` barrel) to avoid a cycle:\n// Database → internal/Entity → entity → JsonSchema → Ref → Database.\nimport { isInstanceOf } from './internal/Entity/type-uri';\nimport * as queryInternal from './internal/Query';\nimport type { Ref } from './internal/Ref/ref';\nimport type * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport type * as Registry from './Registry';\nimport type * as Type from './Type';\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\nexport interface QueryFn {\n  <Q extends Query.Any>(query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n  <F extends Filter.Any>(filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database, Feed, and Hypergraph.\n */\nexport interface Queryable {\n  query: QueryFn;\n}\n\nexport type GetObjectByIdOptions = {\n  deleted?: boolean;\n};\n\nexport type ObjectPlacement = 'root-doc' | 'linked-doc';\n\nexport type AddOptions = {\n  /**\n   * Where to place the object in the Automerge document tree.\n   * Root document is always loaded with the space.\n   * Linked documents are loaded lazily.\n   * Placing large number of objects in the root document may slow down the initial load.\n   *\n   * @default 'linked-doc'\n   */\n  placeIn?: ObjectPlacement;\n};\n\n/**\n * Rejects Type entities from {@link Database.add} at compile time via their `[KindId]` brand. Used\n * as `T & RejectTypeEntity<T>` to preserve inference of `T`. Bounding `add` on\n * `Obj.Unknown | Relation.Unknown` instead would reject broadly-typed instance adds (e.g.\n * `Entity.Any`, `Obj.OfShape<T>`), forcing casts repo-wide.\n */\nexport type RejectTypeEntity<T> = T extends { readonly [KindId]: EntityKind.Type }\n  ? { __error: 'Type entities must be persisted via db.addType(), not db.add().' }\n  : T;\n\nexport type FlushOptions = {\n  /**\n   * Write any pending changes to disk.\n   * @default true\n   */\n  disk?: boolean;\n\n  /**\n   * Wait for pending index updates.\n   * @default true\n   */\n  indexes?: boolean;\n\n  /**\n   * Flush pending updates to objects and queries.\n   * @default false\n   */\n  updates?: boolean;\n};\n\n/**\n * Identifier denoting an ECHO Database.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Database');\nexport type TypeId = typeof TypeId;\n\n/**\n * ECHO Database interface.\n */\nexport interface Database extends Queryable {\n  readonly [TypeId]: TypeId;\n\n  get spaceId(): SpaceId;\n\n  get graph(): Hypergraph.Hypergraph;\n\n  /**\n   * Registry for this database. Delegates type lookups to the shared hypergraph registry.\n   * To persist a schema so it replicates to other clients, add the type entity with\n   * {@link addType} (e.g. `await db.addType(Type.makeObjectFromJsonSchema(...))`).\n   */\n  readonly registry: Registry.Registry;\n\n  toJSON(): object;\n\n  /**\n   * Return object by local ID.\n   * @deprecated Use `db.query(Filter.id(id)).runSync()[0]` for a working-set lookup, or resolve via a {@link Ref}.\n   */\n  getObjectById<T extends Obj.Unknown = Obj.OfShape<AnyProperties>>(\n    id: string,\n    opts?: GetObjectByIdOptions,\n  ): T | undefined;\n\n  /**\n   * Query objects.\n   */\n  query: 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.fromURI`\n   * `Ref.fromURI(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>(uri: URI.URI): Ref<T>;\n\n  /**\n   * Adds an object or relation to the database.\n   *\n   * Only Object and Relation entities are accepted. To persist a Type definition use\n   * {@link addType} — passing a Type entity is rejected at compile time (and at runtime).\n   */\n  add<T extends Entity.Unknown = Entity.Unknown>(obj: T & RejectTypeEntity<T>, opts?: AddOptions): T;\n\n  /**\n   * Persists a Type definition (clones/forks the entity) so it replicates to other peers.\n   *\n   * Runs a conflict query first: if a type with the same typename + version already exists in\n   * this space, the existing persisted entity is returned and no duplicate is created. This is\n   * the only supported way to add Type entities — {@link add} rejects them.\n   */\n  addType<T extends Type.AnyEntity>(type: T): Promise<T>;\n\n  /**\n   * Removes object from the database.\n   */\n  // TODO(burdon): Return true if removed (currently throws if not present).\n  remove(obj: Entity.Unknown): void;\n\n  /**\n   * Appends entities to a feed.\n   *\n   * The feed must already be stored in the database (added via {@link add}); its underlying\n   * queue is addressed by the feed object's URI.\n   */\n  appendToFeed(feed: Feed.Feed, entities: Entity.Unknown[]): Promise<void>;\n\n  /**\n   * Removes entities from a feed.\n   */\n  deleteFromFeed(feed: Feed.Feed, entities: Entity.Unknown[]): Promise<void>;\n\n  /**\n   * Wait for all pending changes to be saved to disk.\n   * Optionaly waits for changes to be propagated to indexes and event handlers.\n   */\n  flush(opts?: FlushOptions): Promise<void>;\n\n  /**\n   * Removes feed items by ID.\n   */\n  removeFeedItemsByIds(feed: Feed.Feed, ids: string[]): Promise<void>;\n\n  /**\n   * Queries items in a feed associated with this database.\n   */\n  queryFeed(feed: Feed.Feed, queryOrFilter: Query.Any | Filter.Any): QueryResult.QueryResult<any>;\n\n  /**\n   * Syncs a feed with the server.\n   */\n  syncFeed(feed: Feed.Feed, options?: Feed.SyncOptions): Promise<void>;\n\n  /**\n   * Returns queue replication backlog for the feed's namespace.\n   */\n  getFeedSyncState(feed: Feed.Feed): Promise<Feed.SyncState>;\n}\n\nexport const isDatabase = (obj: unknown): obj is Database => {\n  return obj ? typeof obj === 'object' && TypeId in obj && obj[TypeId] === TypeId : false;\n};\n\nexport const Database: Schema.Schema<Database> = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));\n\n/**\n * Effect service tag for Database dependency injection.\n */\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {}\n\n/**\n * Layer that provides a Database service that throws when accessed.\n * Useful as a default layer when no database is available.\n */\nexport const notAvailable = Layer.succeed(Service, {\n  get db(): Database {\n    throw new Error('Database not available');\n  },\n});\n\n/**\n * Creates a Database service instance from a Database.\n */\nexport const makeService = (db: Database): Context.Tag.Service<Service> => {\n  return {\n    get db() {\n      return db;\n    },\n  };\n};\n\n/**\n * Creates a Layer that provides the Database service.\n */\nexport const layer = (db: Database): Layer.Layer<Service> => {\n  return Layer.succeed(Service, makeService(db));\n};\n\n/**\n * Returns the space ID of the database.\n */\nexport const spaceId = Effect.gen(function* () {\n  const { db } = yield* Service;\n  return db.spaceId;\n});\n\n/**\n * Resolves an object by its DXN.\n */\nexport const resolve: {\n  // No type check.\n  (ref: URI.URI | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n  // Check matches schema.\n  <S extends Type.AnyEntity>(\n    ref: URI.URI | Ref<any>,\n    schema: S,\n  ): Effect.Effect<Type.InstanceType<S>, Err.EntityNotFoundError, Service>;\n} = (<S extends Type.AnyEntity>(\n  ref: URI.URI | Ref<any>,\n  schema?: S,\n): Effect.Effect<Type.InstanceType<S>, Err.EntityNotFoundError, Service> =>\n  Effect.gen(function* () {\n    const { db } = yield* Service;\n    const dxn = typeof ref === 'string' ? ref : ref.uri;\n    const object = yield* EffectEx.promiseWithCauseCapture(() =>\n      db.graph\n        .createRefResolver({\n          context: {\n            space: db.spaceId,\n          },\n        })\n        .resolveLegacy(dxn),\n    );\n\n    if (!object) {\n      return yield* Effect.fail(new Err.EntityNotFoundError(dxn));\n    }\n    // `isInstanceOf` uses a conditional generic that TS can't resolve through\n    // the local `S extends Type.AnyEntity` parameter — runtime accepts it fine.\n    invariant(!schema || isInstanceOf(schema as any, object), 'Object type mismatch.');\n    return object as any;\n  }).pipe(Effect.withSpan('Database.resolve'))) as any;\n\n/**\n * Loads an object reference.\n *\n * Catching not found error:\n *\n * ```ts\n * yield* load(ref).pipe(Effect.catchTag('EntityNotFoundError', () => Effect.succeed(undefined)));\n * ```\n *\n */\nexport const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.EntityNotFoundError, never> = Effect.fn('Database.load')(\n  function* (ref) {\n    const object = yield* EffectEx.promiseWithCauseCapture(() => ref.tryLoad());\n    if (!object) {\n      return yield* Effect.fail(new Err.EntityNotFoundError(ref.uri));\n    }\n    return object;\n  },\n);\n\n/**\n * Adds an object or relation to the database.\n * @see {@link Database.add}\n */\nexport const add = <T extends Entity.Unknown>(obj: T & RejectTypeEntity<T>): Effect.Effect<T, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.add<T>(obj))).pipe(Effect.withSpan('Database.add'));\n\n/**\n * Persists a Type definition to the database.\n * @see {@link Database.addType}\n */\nexport const addType = <T extends Type.AnyEntity>(type: T): Effect.Effect<T, never, Service> =>\n  Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.addType(type)))).pipe(\n    Effect.withSpan('Database.addType'),\n  );\n\n/**\n * Removes an object from the database.\n * @see {@link Database.remove}\n */\nexport const remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan('Database.remove'));\n\n/**\n * Appends entities to a feed.\n * @see {@link Database.appendToFeed}\n */\nexport const appendToFeed = (feed: Feed.Feed, entities: Entity.Unknown[]): Effect.Effect<void, never, Service> =>\n  Service.pipe(\n    Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.appendToFeed(feed, entities))),\n  ).pipe(Effect.withSpan('Database.appendToFeed'));\n\n/**\n * Removes entities from a feed.\n * @see {@link Database.deleteFromFeed}\n */\nexport const deleteFromFeed = (feed: Feed.Feed, entities: Entity.Unknown[]): Effect.Effect<void, never, Service> =>\n  Service.pipe(\n    Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.deleteFromFeed(feed, entities))),\n  ).pipe(Effect.withSpan('Database.deleteFromFeed'));\n\n/**\n * Flushes pending changes to disk.\n * @see {@link Database.flush}\n */\nexport const flush = (opts?: FlushOptions) =>\n  Service.pipe(Effect.flatMap(({ db }) => EffectEx.promiseWithCauseCapture(() => db.flush(opts)))).pipe(\n    Effect.withSpan('Database.flush'),\n  );\n\n/**\n * Creates a `QueryResult` object that can be subscribed to.\n */\nexport const query: {\n  <Q extends Query.Any>(query: Q): QueryResult.QueryResultEffect<Query.Type<Q>, never, Service>;\n  <F extends Filter.Any>(filter: F): QueryResult.QueryResultEffect<Filter.Type<F>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  Service.pipe(\n    Effect.map(({ db }) => db.query(queryOrFilter as any) as QueryResult.QueryResult<any>),\n    Effect.withSpan('Database.query'),\n    queryInternal.makeQueryResultEffect,\n  );\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, EID, URI } from '@dxos/keys';\n\nimport { getSchemaURI, getTypename } from '../Annotation/annotations';\nimport { type AnyEntity, InstancePhantomId, KindId, TypeId, getStaticTypeSchema } from '../common/types';\nimport { getUri as getUriFromEntity } from './api';\n\n/**\n * @param input schema, `Type.Type` entity, or a type URI (an `echo:` EID or a `dxn:` DXN).\n * @return type identifier URI — see {@link getSchemaURI}. A URI is returned verbatim. For a\n * `Type.Type` entity, the URI of the schema it declares, symmetric with what\n * `Obj.make(typeEntity, ...)` stamps on `system.type`: a static declaration resolves to its\n * typename DXN, a persisted entity to its local `echo:/<objectId>`.\n */\nexport const getTypeURIFromSpecifier = (input: Schema.Schema.All | AnyEntity | URI.URI): URI.URI => {\n  if (Schema.isSchema(input)) {\n    return getSchemaURI(input) ?? raise(new TypeError('Schema has no URI'));\n  }\n  // Type entities are normally proxy objects, but class-declared types from\n  // `Type.makeObject` are functions whose prototype chain reaches the entity, so accept functions too.\n  if (input !== null && (typeof input === 'object' || typeof input === 'function') && KindId in input) {\n    // `Type.Type` entity. Both in-memory and persisted forms expose the schema\n    // they declare via `StaticTypeSchemaSlot`, whose URI is exactly what\n    // `Obj.make` stamps on `system.type` — a static declaration carries\n    // `TypeAnnotation` (→ typename DXN), a persisted entity's rebuilt schema\n    // carries `TypeIdentifierAnnotation` (→ local `echo:/<objectId>`).\n    const schema = getStaticTypeSchema(input);\n    if (schema != null) {\n      // Static types carry TypeAnnotation → DXN; persisted db types carry\n      // TypeIdentifierAnnotation → echo EID. In-memory makeObjectFromJsonSchema\n      // entities have neither (plain JSON Schema), so fall through to the EID path.\n      const uri = getSchemaURI(schema);\n      if (uri != null) {\n        return uri;\n      }\n    }\n    return getUriFromEntity(input as AnyEntity);\n  }\n  // A string specifier is already a branded URI — an `echo:` EID or a `dxn:` DXN.\n  assertArgument(EID.isEID(input) || DXN.isDXN(input), 'input', 'expected a type URI (EID or DXN)');\n  return input;\n};\n\n/**\n * Checks if the object is an instance of the schema.\n * Only typename is compared, the schema version is ignored.\n *\n * The following cases are considered to mean that the object is an instance of the schema:\n *  - Object was created with this exact schema.\n *  - Object was created with a different version of this schema.\n *  - Object was created with a different schema (maybe dynamic) that has the same typename.\n */\n// TODO(burdon): Can we use `Schema.is`?\nexport const isInstanceOf = <S>(\n  schemaOrType: S extends Schema.Schema.AnyNoContext ? S : Schema.Schema.AnyNoContext | AnyEntity,\n  object: any,\n): object is S extends Schema.Schema.AnyNoContext\n  ? Schema.Schema.Type<S>\n  : S extends { readonly [InstancePhantomId]?: infer A }\n    ? A\n    : unknown => {\n  if (object == null) {\n    return false;\n  }\n\n  const schemaURI = getTypeURIFromSpecifier(schemaOrType);\n\n  // `object` is arbitrary input — read TypeId directly (it may be missing on\n  // non-entities) rather than via `getTypeURI` which asserts the URI is set.\n  const type = (object as any)[TypeId];\n  if (URI.isURI(type) && type === schemaURI) {\n    return true;\n  }\n\n  const typename = getTypename(object);\n  if (!typename) {\n    return false;\n  }\n\n  if (!DXN.isDXN(schemaURI)) {\n    // EID-based schema URI — no typename match possible.\n    return false;\n  }\n\n  const parsed = DXN.tryMake(schemaURI);\n  return parsed != null && DXN.getName(parsed) === typename;\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { SchemaEx } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, URI } from '@dxos/keys';\nimport { type Primitive } from '@dxos/util';\n\nimport type * as Annotation from '../../Annotation';\nimport { type Mutable } from '../common/proxy';\nimport { type AnyProperties, EntityKind, TypeId, getSchema } from '../common/types';\nimport { createAnnotationHelper } from './util';\n\nconst ANNOTATION_TYPE_ID: Annotation.TypeId = '~@dxos/echo/Annotation' as const;\n\n/**\n * @internal\n */\nexport const FIELD_PATH_ANNOTATION = 'path';\n\n/**\n * Sets the path for the field.\n * @param path Data source path in the json path format. This is the field path in the source object.\n */\n// TODO(burdon): Field, vs. path vs. property.\nexport const FieldPath = (path: string) => PropertyMeta(FIELD_PATH_ANNOTATION, path);\n\n//\n// Type\n//\n\n/**\n * ECHO identifier (for a stored schema).\n * Must be an `echo:` URI.\n */\nexport const TypeIdentifierAnnotationId = Symbol.for('@dxos/schema/annotation/TypeIdentifier');\n\nexport const getTypeIdentifierAnnotation = (schema: Schema.Schema.All) =>\n  Function.flow(\n    SchemaAST.getAnnotation<string>(TypeIdentifierAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n\n/**\n * @returns The schema's type identifier URI — whichever URI fits.\n *\n * - Stored (dynamic) schemas: the schema-as-object's EID, so loaded objects ride\n *   along with their schema as a strong dependency.\n * - Non-stored (static) schemas: the typename DXN built from `TypeAnnotation`.\n *\n * This URI is what gets written to an object's `system.type`; queries that filter by\n * type also use it (see `Filter.type` / `getTypeURIFromSpecifier`), so both sides\n * stay symmetric without per-schema branching.\n */\nexport const getSchemaURI = (schema: Schema.Schema.All): URI.URI | undefined => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');\n  const id = getTypeIdentifierAnnotation(schema);\n  if (id) {\n    return URI.make(id);\n  }\n  const objectAnnotation = getTypeAnnotation(schema);\n  if (objectAnnotation) {\n    return DXN.make(objectAnnotation.typename, objectAnnotation.version);\n  }\n  return undefined;\n};\n\n//\n// TypeAnnotation\n//\n\n/**\n * Fully qualified globally unique typename.\n * Example: `org.dxos.type.message`\n */\n// TODO(wittjosiah): Factor out to DXN spec.\nexport const TypenameSchema = Schema.String.pipe(\n  Schema.pattern(\n    /^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)$/,\n  ),\n).annotations({\n  description: 'Fully qualified globally unique typename in reverse-DNS form.',\n  example: 'org.dxos.type.message',\n});\n\n/**\n * Semantic version format: `major.minor.patch`\n * Example: `1.0.0`\n */\nexport const VersionSchema = Schema.String.pipe(Schema.pattern(/^\\d+.\\d+.\\d+$/)).annotations({\n  description: 'Semantic version format: `major.minor.patch`',\n  example: '1.0.0',\n});\n\nexport const TypeMeta = Schema.Struct({\n  typename: TypenameSchema,\n  version: VersionSchema,\n});\n\nexport interface TypeMeta extends Schema.Schema.Type<typeof TypeMeta> {}\n\n/**\n * Entity type.\n */\nexport const TypeAnnotationId = Symbol.for('@dxos/schema/annotation/Type');\n\n/**\n * Payload stored under {@link TypeAnnotationId}.\n */\nexport const TypeAnnotation = Schema.extend(\n  TypeMeta,\n  Schema.Struct({\n    kind: Schema.Enums(EntityKind),\n\n    /**\n     * If this is a relation, the schema of the source object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    sourceSchema: Schema.optional(DXN.Schema),\n\n    /**\n     * If this is a relation, the schema of the target object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    targetSchema: Schema.optional(DXN.Schema),\n  }),\n);\n\nexport interface TypeAnnotation extends Schema.Schema.Type<typeof TypeAnnotation> {}\n\n/**\n * @returns {@link TypeAnnotation} from a schema.\n * Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.\n */\nexport const getTypeAnnotation = (schema: Schema.Schema.All): TypeAnnotation | undefined => {\n  assertArgument(schema != null && schema.ast != null, 'schema', 'invalid schema');\n  return Function.flow(\n    SchemaAST.getAnnotation<TypeAnnotation>(TypeAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n};\n\n/**\n * @returns {@link EntityKind} from a schema.\n */\nexport const getEntityKind = (schema: Schema.Schema.All): EntityKind | undefined => getTypeAnnotation(schema)?.kind;\n\n/**\n * @internal\n * @returns Schema typename (without dxn: prefix or version number).\n */\nexport const getSchemaTypename = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.typename;\n\n/**\n * @internal\n * @returns Schema version in semver format.\n */\nexport const getSchemaVersion = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.version;\n\n/**\n * Gets the typename of the object without the version.\n * Returns only the name portion, not the DXN.\n * @example \"org.example.type.contact\"\n *\n * @internal (use Obj.getTypename)\n */\nexport const getTypename = (obj: AnyProperties): string | undefined => {\n  const schema = getSchema(obj);\n  if (schema != null) {\n    // Try to extract typename from DXN.\n    return getSchemaTypename(schema);\n  } else {\n    // `obj` may be an arbitrary value (e.g. from `isInstanceOf`); read TypeId\n    // directly so we return undefined for non-entities instead of throwing.\n    const type = (obj as any)?.[TypeId];\n    // Parse the URI string to extract typename.\n    if (DXN.isDXN(type)) {\n      const parsed = DXN.tryMake(type);\n      return parsed && DXN.getName(parsed);\n    }\n    return undefined;\n  }\n};\n\n/**\n * @internal (use Type.setTypename)\n */\n// TODO(dmaretskyi): Rename setTypeDXN.\nexport const setTypename = (obj: any, typename: URI.URI): void => {\n  assertArgument(typeof typename === 'string', 'typename', 'Invalid type.');\n  Object.defineProperty(obj, TypeId, {\n    value: typename,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n\n/**\n * @returns Object type URI — either a typename {@link DXN} or an `echo:` reference to a stored Schema object.\n * @returns undefined if the object has no registered type URI (e.g. unresolved query result).\n * @example `dxn:com.example.type.person:1.0.0`\n * @example `echo:/01KKKG2FHWCMTR0BY00GJSVT1X` (stored schema)\n *\n * @internal (use Obj.getTypeURI)\n */\nexport const getTypeURI = (obj: AnyProperties): URI.URI | undefined => {\n  if (obj == null) {\n    return undefined;\n  }\n  const type = (obj as any)[TypeId];\n  if (type == null) {\n    return undefined;\n  }\n  invariant(URI.isURI(type), 'Invalid object.');\n  return type;\n};\n\n//\n// PropertyMeta\n//\n\n/**\n * PropertyMeta (metadata for dynamic schema properties).\n * For user-defined annotations.\n */\nexport const PropertyMetaAnnotationId = Symbol.for('@dxos/schema/annotation/PropertyMeta');\n\nexport type PropertyMetaValue = Primitive | Record<string, Primitive> | Primitive[];\n\nexport type PropertyMetaAnnotation = {\n  [name: string]: PropertyMetaValue;\n};\n\n// TODO(wittjosiah): Align with other annotations.\n// TODO(wittjosiah): Why is this separate from FormatAnnotation?\n/**\n * Apply property-level metadata to an Effect schema. Only accepts\n * `Schema.Schema.Any` — apply BEFORE wrapping the schema with\n * `Type.makeObject` / `Type.makeRelation`. To read property meta off a\n * `Type.Type` entity, unwrap it first with `Type.getSchema(entity)`.\n */\nexport const PropertyMeta = (name: string, value: PropertyMetaValue) => {\n  return <A, I, R>(self: Schema.Schema<A, I, R>): Schema.Schema<A, I, R> => {\n    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId] as PropertyMetaAnnotation;\n    return self.annotations({\n      [PropertyMetaAnnotationId]: {\n        ...existingMeta,\n        [name]: value,\n      },\n    });\n  };\n};\n\nexport const getPropertyMetaAnnotation = <T>(prop: SchemaAST.PropertySignature, name: string) =>\n  Function.pipe(\n    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(prop.type),\n    Option.map((meta) => meta[name] as T),\n    Option.getOrElse(() => undefined),\n  );\n\n//\n// Reference\n//\n\n/**\n * Schema reference.\n */\nexport const ReferenceAnnotationId = Symbol.for('@dxos/schema/annotation/Reference');\nexport type ReferenceAnnotationValue = TypeAnnotation;\nexport const ReferenceAnnotation = createAnnotationHelper<ReferenceAnnotationValue>(ReferenceAnnotationId);\n\n/**\n * SchemaMeta.\n */\nexport const SchemaMetaSymbol = Symbol.for('@dxos/schema/SchemaMeta');\nexport type SchemaMeta = TypeMeta & { id: string };\n\n/**\n * Identifies a schema as hidden from user-facing surfaces (like dotfiles — visible only via an advanced setting).\n */\nexport const HiddenAnnotationId = Symbol.for('@dxos/schema/annotation/Hidden');\nexport const HiddenAnnotation = createAnnotationHelper<boolean>(HiddenAnnotationId);\n\n/**\n * Identifies label property or JSON path expression.\n * Either a string or an array of strings representing field accessors each matched in priority order.\n */\nexport const LabelAnnotationId = Symbol.for('@dxos/schema/annotation/Label');\nexport const LabelAnnotation = createAnnotationHelper<string[]>(LabelAnnotationId);\n\n/**\n * Returns the label for a given object based on {@link LabelAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n * Skips empty strings and whitespace-only strings, continuing to the next field.\n */\n// TODO(burdon): Convert to SchemaEx.JsonPath?\nexport const getLabelWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n): string | undefined => {\n  const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => ['name']));\n  for (const accessor of annotation) {\n    assertArgument(\n      typeof accessor === 'string',\n      'accessor',\n      'Label annotation must be a string or an array of strings',\n    );\n    const value = SchemaEx.getField(object, accessor as SchemaEx.JsonPath);\n    switch (typeof value) {\n      case 'string': {\n        const trimmed = value.trim();\n        if (trimmed.length > 0) {\n          return value;\n        }\n        continue;\n      }\n      case 'number':\n      case 'boolean':\n      case 'bigint':\n      case 'symbol':\n        return value.toString();\n      case 'undefined':\n      case 'object':\n      case 'function':\n        continue;\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Sets the label for a given object based on {@link LabelAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\nexport const setLabelWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n  label: string,\n) => {\n  const annotation = LabelAnnotation.get(schema).pipe(\n    Option.map((field) => field[0]),\n    Option.getOrElse(() => 'name'),\n  );\n  object[annotation] = label;\n};\n\n/**\n * Identifies description property or JSON path expression.\n * A string representing field accessor.\n */\nexport const DescriptionAnnotationId = Symbol.for('@dxos/schema/annotation/Description');\nexport const DescriptionAnnotation = createAnnotationHelper<string>(DescriptionAnnotationId);\n\n/**\n * Returns the description for a given object based on {@link DescriptionAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\n// TODO(burdon): Convert to SchemaEx.JsonPath?\nexport const getDescriptionWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n): string | undefined => {\n  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  assertArgument(typeof accessor === 'string', 'accessor', 'Description annotation must be a string');\n  const value = SchemaEx.getField(object, accessor as SchemaEx.JsonPath);\n  switch (typeof value) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'bigint':\n    case 'symbol':\n      return value.toString();\n    case 'undefined':\n    case 'object':\n    case 'function':\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Sets the description for a given object based on {@link DescriptionAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\nexport const setDescriptionWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n  description: string,\n) => {\n  const accessorOpt = DescriptionAnnotation.get(schema);\n  if (Option.isNone(accessorOpt)) {\n    return;\n  }\n  object[accessorOpt.value] = description;\n};\n\n/**\n * Identifies if a property should be included in a form or not.\n * By default, all properties are included in forms, so this is opt-out.\n */\nexport const FormInputAnnotationId = Symbol.for('@dxos/schema/annotation/FormInput');\nexport const FormInputAnnotation = createAnnotationHelper<boolean>(FormInputAnnotationId);\n\n/**\n * When set on a `Ref` property, the form renders the referenced object's own\n * fields inline (a nested form bound to the target) instead of a picker.\n */\nexport const FormInlineAnnotationId = Symbol.for('@dxos/schema/annotation/FormInline');\nexport const FormInlineAnnotation = createAnnotationHelper<boolean>(FormInlineAnnotationId);\n\n/**\n * When set on a `Ref` (or array-of-`Ref`) property, the form OWNS the referenced target(s): \"add\" creates a\n * new object of the annotation's typename (instead of opening the existing-object picker) and each target is\n * rendered inline — its own fields — like {@link FormInlineAnnotation}. The target typename is carried here\n * (rather than inferred from the element type) so the field can stay `Ref.Ref(Obj.Unknown)` and avoid pulling\n * the target's type (e.g. query-AST-laden `Trigger`) into the schema's emitted declaration.\n */\nexport const FormCreateAnnotationId = Symbol.for('@dxos/schema/annotation/FormCreate');\nexport const FormCreateAnnotation = createAnnotationHelper<string>(FormCreateAnnotationId);\n\n/**\n * When set on an array property, the form renders it as an ordered,\n * drag-to-reorder list (drag handles per row). Element order is meaningful and\n * user-controllable; reordering rewrites the array.\n */\nexport const FormOrderedAnnotationId = Symbol.for('@dxos/schema/annotation/FormOrdered');\nexport const FormOrderedAnnotation = createAnnotationHelper<boolean>(FormOrderedAnnotationId);\n\n/**\n * Annotation carrying one or more named layout DSL templates that control how a\n * form arranges a schema's fields (consumed by `@dxos/react-ui-form`'s\n * `Form.Layout` / `Form.FieldSet`). Callers select a variant by name; the\n * implicit name is `DEFAULT_LAYOUT_NAME` (`'default'`).\n *\n * Templates use a minimal XML grammar. Example:\n *\n *   FormLayoutAnnotation.set({\n *     default: `\n *       <grid cols=\"2\">\n *         <field name=\"origin\"/>\n *         <field name=\"destination\"/>\n *         <field name=\"provider\" span=\"2\"/>\n *       </grid>\n *     `,\n *     card: `\n *       <grid cols=\"1\">\n *         <field name=\"provider\"/>\n *         <field name=\"number\"/>\n *       </grid>\n *     `,\n *   })\n */\nexport const FormLayoutAnnotationId = Symbol.for('@dxos/react-ui-form/annotation/Layout');\n\nexport type FormLayoutMap = Record<string, string>;\n\nexport const FormLayoutAnnotation = createAnnotationHelper<FormLayoutMap>(FormLayoutAnnotationId);\n\n/** Name used when no explicit form-layout variant is requested. */\nexport const DEFAULT_LAYOUT_NAME = 'default';\n\n/**\n * Default field to be used on referenced schema to lookup the value.\n */\nexport const FieldLookupAnnotationId = Symbol.for('@dxos/schema/annotation/FieldLookup');\n\n/**\n * Generate test data.\n */\nexport const GeneratorAnnotationId = Symbol.for('@dxos/schema/annotation/Generator');\n\nexport type GeneratorAnnotationValue =\n  | string\n  | {\n      generator: string;\n      args?: any[];\n      probability?: number;\n    };\n\nexport const GeneratorAnnotation = createAnnotationHelper<GeneratorAnnotationValue>(GeneratorAnnotationId);\n\ninterface MakeAnnoationsProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n// Annotation ids use the same NSID / reverse-DNS format as TypenameSchema —\n// dot-separated segments, middle segments may be hyphenated, final segment may be camelCase.\n// At least 3 segments are required (e.g. org.dxos.annotation.example).\nexport const makeUserAnnotation = <T>(props: MakeAnnoationsProps<T>): Annotation.Annotation<T> => {\n  assertArgument(\n    /^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?){2,}(\\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)?$/.test(\n      props.id,\n    ),\n    'id',\n    'Annotation id must be in the FQN format (org.dxos.annotation.example or org.dxos.space.rootCollection).',\n  );\n\n  const annotation: Annotation.Annotation<T> = {\n    [ANNOTATION_TYPE_ID]: { _Type: {} as T },\n    key: props.id as Annotation.Key,\n    schema: props.schema,\n    get: (schema) => getFromAst(schema.ast, annotation),\n    getFromAst: (ast) => getFromAst(ast, annotation),\n    set: (value) =>\n      PropertyMeta(props.id, Schema.encodeSync(props.schema)(value)) as <S extends Schema.Schema.Any>(schema: S) => S,\n  };\n\n  return annotation;\n};\n\nconst IconAnnotationSchema = Schema.Struct({\n  /**\n   * Phosphor icon name (e.g., 'ph--user--regular', 'ph--cube--regular', 'ph--link--regular ', etc.)\n   */\n  icon: Schema.String.pipe(Schema.pattern(/^ph--[a-z-]+--[a-z]+$/)),\n\n  /**\n   * Color name.\n   *\n   * List of colors:\n   *  - 'red'\n   *  - 'orange'\n   *  - 'amber'\n   *  - 'yellow'\n   *  - 'lime'\n   *  - 'green'\n   *  - 'emerald'\n   *  - 'teal'\n   *  - 'cyan'\n   *  - 'violet'\n   *  - 'purple'\n   *  - 'fuchsia'\n   *  - 'pink'\n   *  - 'rose'\n   */\n  hue: Schema.optional(Schema.String),\n});\n\nexport interface IconAnnotation extends Schema.Schema.Type<typeof IconAnnotationSchema> {}\n\n/**\n * Icon to render in the UI.\n */\nexport const IconAnnotation = makeUserAnnotation<IconAnnotation>({\n  id: 'org.dxos.annotation.icon',\n  schema: IconAnnotationSchema,\n});\n\n/**\n * Indicates that this entity's icon should be resolved from a property whose value is a `Ref`\n * to another entity. Consumers (e.g. graph node builders) resolve the ref target and use that\n * target's schema `IconAnnotation` in place of the static one declared on this schema.\n *\n * Useful for wrapper schemas that delegate their visual identity to a referenced sub-entity\n * (e.g. a generic `Game` whose icon should come from its `variant` ref's typed state).\n */\nexport const IconFromRefAnnotation = makeUserAnnotation<string>({\n  id: 'org.dxos.annotation.icon.from-ref',\n  schema: Schema.String,\n});\n\n/**\n * Options for {@link getLabel}.\n */\nexport type GetLabelOptions = {\n  /**\n   * Strategy for deriving a label when the entity has no `LabelAnnotation` value.\n   * - `'typename'`: use the entity's typename (e.g. `org.dxos.type.table`).\n   *   Useful for Card.Title chrome that must always display something, even\n   *   for unlabeled objects.\n   */\n  fallback?: 'typename';\n};\n\n/**\n * Get the label of an entity.\n * Accepts both reactive entities and snapshots.\n *\n * If `options.fallback === 'typename'` and no label is set, returns the\n * entity's typename instead.\n */\nexport const getLabel = (entity: AnyProperties, options?: GetLabelOptions): string | undefined => {\n  const schema = getSchema(entity);\n  const label = schema != null ? getLabelWithSchema(schema, entity) : undefined;\n  if (label != null) {\n    return label;\n  }\n  if (options?.fallback === 'typename') {\n    return getTypename(entity);\n  }\n  return undefined;\n};\n\n/**\n * Set the label of an entity.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const setLabel = (entity: Mutable<AnyProperties>, label: string) => {\n  const schema = getSchema(entity);\n  if (schema != null) {\n    setLabelWithSchema(schema, entity, label);\n  }\n};\n\n/**\n * Returns the primary label property key for an entity.\n * Reads the first accessor from {@link LabelAnnotation}, defaulting to 'name'.\n */\nexport const getLabelProperty = (entity: AnyProperties): string => {\n  const schema = getSchema(entity);\n  if (schema == null) {\n    return 'name';\n  }\n  return LabelAnnotation.get(schema).pipe(\n    Option.flatMap((fields) => Option.fromNullable(fields[0])),\n    Option.getOrElse(() => 'name'),\n  );\n};\n\n/**\n * Get the description of an entity.\n * Accepts both reactive entities and snapshots.\n */\nexport const getDescription = (entity: AnyProperties): string | undefined => {\n  const schema = getSchema(entity);\n  if (schema != null) {\n    return getDescriptionWithSchema(schema, entity);\n  }\n};\n\n/**\n * Get the icon annotation for an entity, resolved via its type-level `IconAnnotation`.\n * Accepts both reactive entities and snapshots.\n *\n * Returns the full `{ icon, hue }` annotation so callers can use both the phosphor icon\n * name and the suggested colour. Callers wanting just the icon name typically write\n * `Obj.getIcon(obj)?.icon ?? 'ph--cube--regular'`.\n *\n * Note: this is the \"static\" icon from the object's own schema. It does not follow\n * `IconFromRefAnnotation` delegation — call sites needing that (e.g. app-graph node\n * builders) should resolve the ref themselves.\n */\nexport const getIcon = (entity: AnyProperties): IconAnnotation | undefined => {\n  const schema = getSchema(entity);\n  if (schema == null) {\n    return undefined;\n  }\n  return Option.getOrUndefined(IconAnnotation.get(schema));\n};\n\n/**\n * Set the description of an entity.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const setDescription = (entity: Mutable<AnyProperties>, description: string) => {\n  const schema = getSchema(entity);\n  if (schema != null) {\n    setDescriptionWithSchema(schema, entity, description);\n  }\n};\n\nexport { Dictionary, Key, getDictionary, setDictionary } from './dictionary';\n\nexport const getFromAst = <T>(ast: SchemaAST.AST, annotation: Annotation.Annotation<T>): Option.Option<T> => {\n  return SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(ast).pipe(\n    Option.flatMap((meta) => Option.fromNullable(meta[annotation.key])),\n    Option.map(Schema.decodeUnknownSync(annotation.schema)),\n  );\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\n// TODO(rename): These internal entity-wide symbols/types still use the `Object*` prefix but apply\n// to all entities (objects AND relations). Rename to `Entity*` in a follow-up pass (deferred from the\n// EchoURI→EID / ObjectId→EntityId / ObjectMeta→EntityMeta rename, which covered only public SDK API):\n//   ObjectCore, ObjectInternals, ObjectVersion, ObjectVersionId, ObjectDeletedId, ObjectDatabaseId,\n//   ObjectLoader, ObjectDocumentLoaded, ObjectUnavailable.\n// (ObjectMigration / ObjectMigrationContext intentionally excluded — object-only, not entity-wide.)\n\n/**\n * Internal symbol/string constants for the echo object model.\n * Defined in common/ so proxy/ can use them without importing from Entity/.\n * Entity/ re-exports these for external consumers.\n */\n\n/**\n * Property name for the object's own URI when serialized to JSON.\n */\nexport const ATTR_SELF_URI = '@uri';\n\n/**\n * @deprecated Legacy JSON property name accepted on read for backward compat.\n */\nexport const ATTR_SELF_URI_LEGACY = '@dxn';\n\n/**\n * Symbol carrying the object's own URI on live entities.\n */\nexport const SelfURIId = Symbol.for('@dxos/echo/URI');\n\n/**\n * Property name for deleted when object is serialized to JSON.\n */\nexport const ATTR_DELETED = '@deleted';\n\n/**\n * Deletion marker.\n */\nexport const ObjectDeletedId = Symbol.for('@dxos/echo/Deleted');\n\n/**\n * Object version accessor symbol.\n */\nexport const ObjectVersionId: unique symbol = Symbol.for('@dxos/echo/Version');\n\n/**\n * Object database accessor symbol.\n */\nexport const ObjectDatabaseId = Symbol.for('@dxos/echo/Database');\n\n/**\n * Property name for relation source when object is serialized to JSON.\n */\nexport const ATTR_RELATION_SOURCE = '@relationSource';\n\n/**\n * Used to access relation source ref on live ECHO objects.\n */\nexport const RelationSourceId: unique symbol = Symbol.for('@dxos/echo/RelationSource');\n\n/**\n * Used to access relation source DXN on live ECHO objects.\n */\nexport const RelationSourceDXNId: unique symbol = Symbol.for('@dxos/echo/RelationSourceDXN');\n\n/**\n * Property name for relation target when object is serialized to JSON.\n */\nexport const ATTR_RELATION_TARGET = '@relationTarget';\n\n/**\n * Used to access relation target ref on live ECHO objects.\n */\nexport const RelationTargetId: unique symbol = Symbol.for('@dxos/echo/RelationTarget');\n\n/**\n * Used to access relation target DXN on live ECHO objects.\n */\nexport const RelationTargetDXNId: unique symbol = Symbol.for('@dxos/echo/RelationTargetDXN');\n\n/**\n * Symbol carrying the entity metadata (EntityMeta) on live ECHO entities.\n * Must be importable by both meta.ts (which depends on the Ref schema) and\n * Entity/api.ts (which is transitively imported by the Ref schema), so it\n * cannot live in either of those files without creating an import cycle.\n */\nexport const MetaId = Symbol.for('@dxos/echo/Meta');\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\n/**\n * Property name for typename when object is serialized to JSON.\n */\nexport const ATTR_TYPE = '@type';\n\n/**\n * DXN to the object type.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Type');\n\n/**\n * Reference to the object schema.\n */\nexport const SchemaId = Symbol.for('@dxos/echo/Schema');\n\n/**\n * Property name for parent when object is serialized to JSON.\n */\nexport const ATTR_PARENT = '@parent';\n\n/**\n * Reference to the object parent.\n */\nexport const ParentId = Symbol.for('@dxos/echo/Parent');\n\n/**\n * Reference to the object's type entity (`Type.Obj`, `Type.Relation`, or\n * `Type.Type`). Set at instance creation by `createObject` / `makeObject`\n * when the entity is known. Public read-back via `Obj.getType` / `Relation.getType`\n * / `Entity.getType`.\n */\nexport const TypeEntityId = Symbol.for('@dxos/echo/TypeEntity');\n\n/**\n * Returns the Effect Schema for the given object if one is defined.\n *\n * @internal\n * Internal callers needing schema-side validation read from `SchemaId`.\n * Public callers should use `Type.getSchema(Obj.getType(obj))` instead.\n */\n// TODO(dmaretskyi): For echo objects, this always returns the root schema.\nexport const getSchema = (obj: unknown | undefined): Schema.Schema.AnyNoContext | undefined => {\n  if (obj) {\n    return (obj as any)[SchemaId];\n  }\n};\n\n/**\n * @internal\n */\nexport const setSchema = (obj: any, schema: Schema.Schema.AnyNoContext): void => {\n  Object.defineProperty(obj, SchemaId, {\n    value: schema,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n\n/**\n * Returns the type entity (`Type.AnyEntity`) for the given instance.\n * Set at instance creation; every entity has a type. Defensive: returns\n * undefined for null/undefined input so callers can safely probe arbitrary\n * values via this helper.\n *\n * @internal Re-exported via `Obj.getType` / `Relation.getType` / `Entity.getType`.\n */\nexport const getType = (obj: unknown): unknown => {\n  if (obj == null) {\n    return undefined;\n  }\n  return (obj as any)[TypeEntityId];\n};\n\n/**\n * @internal\n */\nexport const setType = (obj: any, type: unknown): void => {\n  Object.defineProperty(obj, TypeEntityId, {\n    value: type,\n    writable: false,\n    enumerable: false,\n    configurable: true,\n  });\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as Types from 'effect/Types';\n\nimport type * as Annotation from '../../Annotation';\n\n/**\n * Unique identifier for an annotation.\n */\nexport const Key = Schema.String.pipe(Schema.brand('~@dxos/echo/AnnotationKey'));\nexport type Key = Schema.Schema.Type<typeof Key>;\n\n/**\n * Set of annotation values stored on entity meta or nested in schemas.\n */\nexport const Dictionary = Schema.Record({ key: Key, value: Schema.Unknown });\nexport interface Dictionary extends Schema.Schema.Type<typeof Dictionary> {}\n\n/**\n * Get the value of an annotation from a dictionary.\n */\nexport const getDictionary = <T>(\n  values: Annotation.Dictionary,\n  annotation: Annotation.Annotation<T>,\n): Option.Option<T> => {\n  if (!(annotation.key in values)) {\n    return Option.none();\n  }\n\n  return Function.pipe(values[annotation.key], Schema.decodeUnknownSync(annotation.schema), Option.some);\n};\n\n/**\n * Set the value of an annotation in a dictionary.\n */\nexport const setDictionary = <T>(\n  values: Types.Mutable<Annotation.Dictionary>,\n  annotation: Annotation.Annotation<T>,\n  value: T,\n): void => {\n  values[annotation.key] = Schema.encodeSync(annotation.schema)(value);\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport { invariant } from '@dxos/invariant';\nimport { DXN, EID, type SpaceId, URI } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type { AnyEntity } from '../common/types';\nimport { MetaId } from '../common/types/model-symbols';\nimport { type InternalObjectProps, ObjectDatabaseId } from './model';\nimport { getObjectEchoUri } from './util';\n\n/**\n * Controls the URI form returned by `getUri` and the public `*.getURI` helpers.\n *\n * - `'named'`    — Registry key URI (`dxn:<meta.key>`) when the entity has a key in its meta;\n *                  falls back to the default EID.\n * - `'absolute'` — Fully-qualified EID with space id (`echo://<spaceId>/<entityId>`);\n *                  falls back when no space is available.\n * - `'relative'` — Local EID without space id (`echo:/<entityId>`).\n *\n * Omitting `prefer` preserves the existing behaviour.\n */\nexport type GetURIOptions = {\n  prefer?: 'named' | 'absolute' | 'relative';\n};\n\n/**\n * Get the URI of an entity.\n * Accepts both reactive entities and snapshots.\n */\nexport const getUri = (entity: AnyEntity, options?: GetURIOptions): URI.URI => {\n  const prefer = options?.prefer;\n\n  if (prefer === 'named') {\n    const key = (entity as any)[MetaId]?.key;\n    if (key) {\n      return (DXN.tryMake(`dxn:${key}`) ?? URI.make(key)) as URI.URI;\n    }\n    const uri = getObjectEchoUri(entity);\n    invariant(uri != null, 'Invalid entity.');\n    return uri;\n  }\n\n  if (prefer === 'relative') {\n    const eid = getObjectEchoUri(entity);\n    invariant(eid != null, 'Invalid entity.');\n    const entityId = EID.getEntityId(eid);\n    return entityId ? EID.make({ entityId }) : eid;\n  }\n\n  if (prefer === 'absolute') {\n    const eid = getObjectEchoUri(entity);\n    invariant(eid != null, 'Invalid entity.');\n    const entityId = EID.getEntityId(eid);\n    if (!entityId) {\n      return eid;\n    }\n    assumeType<InternalObjectProps>(entity);\n    const spaceId: SpaceId | undefined = entity[ObjectDatabaseId]?.spaceId ?? EID.getSpaceId(eid);\n    return spaceId ? EID.make({ spaceId, entityId }) : eid;\n  }\n\n  const uri = getObjectEchoUri(entity);\n  invariant(uri != null, 'Invalid entity.');\n  return uri;\n};\n\n/**\n * Get the database the entity belongs to.\n * Accepts both reactive entities and snapshots.\n */\nexport const getDatabase = (entity: AnyEntity): any | undefined => {\n  assumeType<InternalObjectProps>(entity);\n  return entity[ObjectDatabaseId];\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type ForeignKey } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { EID, EntityId, type URI } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from '../../Database';\nimport {\n  ATTR_DELETED,\n  type ATTR_PARENT,\n  ATTR_RELATION_SOURCE,\n  ATTR_RELATION_TARGET,\n  ATTR_SELF_URI,\n  ATTR_SELF_URI_LEGACY,\n  type ATTR_TYPE,\n  EntityKind,\n  KindId,\n  ObjectDatabaseId,\n  ObjectDeletedId,\n  ObjectVersionId,\n  type ParentId,\n  RelationSourceDXNId,\n  RelationSourceId,\n  RelationTargetDXNId,\n  RelationTargetId,\n  type SchemaId,\n  SelfURIId,\n  TypeId,\n  type Version,\n} from '../common/types';\nimport { type ATTR_META, type EntityMeta } from '../common/types/meta';\nimport { type MetaId } from '../common/types/model-symbols';\n\nexport {\n  ATTR_DELETED,\n  ATTR_SELF_URI,\n  ATTR_SELF_URI_LEGACY,\n  ObjectDatabaseId,\n  ObjectDeletedId,\n  ObjectVersionId,\n  SelfURIId,\n};\n\n/**\n * Internal runtime representation of an object.\n * The fields are accessed through getter functions.\n */\n// NOTE: Each symbol has a jsdoc describing its purpose.\nexport interface InternalObjectProps {\n  readonly id: EntityId;\n  readonly [SelfURIId]: EID.EID;\n  readonly [KindId]: EntityKind;\n  readonly [SchemaId]: Schema.Schema.AnyNoContext;\n  readonly [TypeId]: URI.URI;\n  readonly [MetaId]?: EntityMeta;\n  [ParentId]?: InternalObjectProps;\n  readonly [ObjectDatabaseId]?: Database.Database;\n  readonly [ObjectDeletedId]?: boolean;\n  readonly [ObjectVersionId]?: Version;\n  readonly [RelationSourceDXNId]?: EID.EID;\n  readonly [RelationTargetDXNId]?: EID.EID;\n  readonly [RelationSourceId]?: InternalObjectProps;\n  readonly [RelationTargetId]?: InternalObjectProps;\n}\n\n/**\n * Entity metadata.\n */\nexport interface EntityMetaJSON {\n  keys: ForeignKey[];\n  tags?: string[];\n  key?: string;\n  version?: string;\n}\n\n/**\n * JSON representation of an object or relation metadata.\n */\nexport interface ObjectJSON {\n  id: EntityId;\n  [ATTR_TYPE]?: URI.URI;\n  [ATTR_SELF_URI]?: EID.EID;\n  [ATTR_PARENT]?: EID.EID; // Encoded reference\n  [ATTR_DELETED]?: boolean;\n  [ATTR_META]?: EntityMetaJSON;\n  [ATTR_RELATION_SOURCE]?: EID.EID;\n  [ATTR_RELATION_TARGET]?: EID.EID;\n\n  /**\n   * Application-specific properties.\n   */\n  [key: string]: unknown;\n}\n\n/**\n * NOTE: Keep as `function` to avoid type inference issues.\n */\nexport function assertObjectModel(obj: unknown): asserts obj is InternalObjectProps {\n  invariant(typeof obj === 'object' && obj !== null, 'Invalid object model: not an object');\n  assumeType<InternalObjectProps>(obj);\n  invariant(EntityId.isValid(obj.id), 'Invalid object model: invalid id');\n  invariant(obj[TypeId] === undefined || typeof obj[TypeId] === 'string', 'Invalid object model: invalid type');\n  invariant(\n    obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type,\n    'Invalid object model: invalid entity kind',\n  );\n\n  if (obj[KindId] === EntityKind.Relation) {\n    invariant(EID.isEID(obj[RelationSourceDXNId]), 'Invalid object model: invalid relation source');\n    invariant(EID.isEID(obj[RelationTargetDXNId]), 'Invalid object model: invalid relation target');\n    invariant(!EID.isEID(obj[RelationSourceId]), 'Invalid object model: source pointer is a DXN');\n    invariant(!EID.isEID(obj[RelationTargetId]), 'Invalid object model: target pointer is a DXN');\n  }\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { EID, EntityId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport { type InternalObjectProps, SelfURIId } from './model';\n\n/**\n * Returns the EID of an object.\n *\n * @internal\n */\nexport const getObjectEchoUri = (object: any): EID.EID | undefined => {\n  invariant(!Schema.isSchema(object), 'schema not allowed in this function');\n  assertArgument(typeof object === 'object' && object != null, 'object', 'expected object');\n  assumeType<InternalObjectProps>(object);\n\n  if (object[SelfURIId]) {\n    invariant(EID.isEID(object[SelfURIId]), 'Invalid object model: invalid self dxn');\n    return EID.parse(object[SelfURIId]);\n  }\n\n  if (!EntityId.isValid(object.id)) {\n    throw new TypeError('Object id is not valid.');\n  }\n\n  return EID.make({ entityId: object.id });\n};\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Effectable from 'effect/Effectable';\nimport * as Option from 'effect/Option';\n\nimport { EffectEx } from '@dxos/effect';\n\nimport type * as QueryResult from '../../QueryResult';\n\n/**\n * Wraps an effect that produces a {@link QueryResult.QueryResult} into a\n * {@link QueryResult.QueryResultEffect}, exposing `.run` and `.first` shorthands that execute the\n * query once. Shared by `Database.query` and `Feed.query` so both surfaces chain identically.\n */\nexport const makeQueryResultEffect = <T, E, R>(\n  eff: Effect.Effect<QueryResult.QueryResult<T>, E, R>,\n): QueryResult.QueryResultEffect<T, E, R> => {\n  return {\n    run: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(() => result.run())),\n    first: Effect.flatMap(eff, (result) =>\n      EffectEx.promiseWithCauseCapture(async () => Option.fromNullable(await result.firstOrUndefined())),\n    ),\n\n    // Effect internals: the result is itself an Effect, so it carries the commit prototype.\n    ...Effectable.CommitPrototype,\n    commit() {\n      return eff;\n    },\n    // Cast required: Effect's commit protocol is supplied at runtime via `CommitPrototype` and\n    // cannot be expressed by the object literal's static type.\n  } as any;\n};\n"],
+  "mappings": "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",
+  "names": ["TypeId", "Context", "Effect", "Layer", "Schema", "EffectEx", "invariant", "Schema", "raise", "assertArgument", "DXN", "EID", "URI", "Function", "Option", "Schema", "SchemaAST", "SchemaEx", "assertArgument", "invariant", "DXN", "URI", "ATTR_SELF_URI", "ATTR_SELF_URI_LEGACY", "SelfURIId", "Symbol", "for", "ATTR_DELETED", "ObjectDeletedId", "ObjectVersionId", "ObjectDatabaseId", "ATTR_RELATION_SOURCE", "RelationSourceId", "RelationSourceDXNId", "ATTR_RELATION_TARGET", "RelationTargetId", "RelationTargetDXNId", "MetaId", "ATTR_TYPE", "TypeId", "Symbol", "for", "SchemaId", "ATTR_PARENT", "ParentId", "TypeEntityId", "getSchema", "obj", "setSchema", "schema", "Object", "defineProperty", "value", "writable", "enumerable", "configurable", "getType", "undefined", "setType", "type", "Function", "Option", "Schema", "Key", "String", "pipe", "brand", "Dictionary", "Record", "key", "value", "Unknown", "getDictionary", "values", "annotation", "none", "decodeUnknownSync", "schema", "some", "setDictionary", "encodeSync", "ANNOTATION_TYPE_ID", "id", "getTypeIdentifierAnnotation", "URI", "objectAnnotation", "typename", "undefined", "example", "TypeMeta", "version", "VersionSchema", "Function", "getAnnotation", "schema", "getSchemaTypename", "DXN", "type", "parsed", "Object", "defineProperty", "obj", "TypeId", "writable", "enumerable", "configurable", "invariant", "existingMeta", "self", "annotations", "PropertyMetaAnnotationId", "value", "assertArgument", "SchemaEx", "getField", "annotation", "label", "object", "accessor", "Option", "isNone", "DEFAULT_LAYOUT_NAME", "key", "get", "getFromAst", "ast", "set", "PropertyMeta", "Schema", "encodeSync", "IconAnnotationSchema", "getLabelWithSchema", "options", "setLabelWithSchema", "entity", "LabelAnnotation", "getDescriptionWithSchema", "setDescriptionWithSchema", "invariant", "DXN", "EID", "URI", "assumeType", "invariant", "EID", "EntityId", "assumeType", "__dxlog_file", "ATTR_DELETED", "assumeType", "obj", "invariant", "EntityId", "isValid", "__dxlog_file", "TypeId", "KindId", "EntityKind", "Type", "EID", "isEID", "RelationSourceDXNId", "RelationTargetDXNId", "Schema", "assertArgument", "invariant", "EID", "EntityId", "assumeType", "__dxlog_file", "assertArgument", "object", "assumeType", "SelfURIId", "invariant", "EID", "EntityId", "isValid", "make", "__dxlog_file", "prefer", "key", "MetaId", "DXN", "tryMake", "uri", "getObjectEchoUri", "entity", "invariant", "eid", "entityId", "getEntityId", "make", "assumeType", "spaceId", "EID", "ObjectDatabaseId", "getTypeURIFromSpecifier", "input", "isSchema", "getSchemaURI", "raise", "TypeError", "KindId", "schema", "getStaticTypeSchema", "uri", "getUriFromEntity", "assertArgument", "EID", "isEID", "DXN", "isDXN", "isInstanceOf", "schemaOrType", "object", "schemaURI", "type", "TypeId", "URI", "isURI", "typename", "getTypename", "parsed", "tryMake", "getName", "Effect", "Effectable", "Option", "EffectEx", "makeQueryResultEffect", "eff", "run", "flatMap", "result", "promiseWithCauseCapture", "first", "fromNullable", "firstOrUndefined", "CommitPrototype", "commit", "__dxlog_file", "obj", "TypeId", "Database", "Schema", "Any", "space", "isDatabase", "db", "spaceId", "dxn", "ref", "object", "EffectEx", "context", "resolveLegacy", "Effect", "fail", "pipe", "withSpan", "EntityNotFoundError", "uri"]
+}

package/dist/lib/neutral/{chunk-E7IOTOZD.mjs → chunk-42L4HJ3Z.mjs}

@@ -1,23 +1,23 @@
 import {
   foreignKeys,
   type
-} from "./chunk-NOL7O3BL.mjs";
+} from "./chunk-SCT6FFCR.mjs";
 import {
   Meta,
   getMeta,
   make,
   update
-} from "./chunk-6CEISA3V.mjs";
+} from "./chunk-HBXT3GSB.mjs";
 import {
   makeObject
-} from "./chunk-HGWQR5KH.mjs";
+} from "./chunk-XB6ISRAO.mjs";
 import {
   TagTypeDXN
-} from "./chunk-X3NUUON4.mjs";
+} from "./chunk-2HKGAQM4.mjs";
 import {
   HiddenAnnotation,
   LabelAnnotation
-} from "./chunk-WZ32BF53.mjs";
+} from "./chunk-3TN2VMI4.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -33,17 +33,13 @@ __export(Tag_exports, {
   sortTags: () => sortTags
 });
 import * as Schema from "effect/Schema";
-var Tag = Schema.Struct({
+var Tag = class extends makeObject(TagTypeDXN)(Schema.Struct({
   label: Schema.String,
   hue: Schema.optional(Schema.String)
-}).pipe(
-  LabelAnnotation.set([
-    "label"
-  ]),
-  HiddenAnnotation.set(true),
-  // Shared DXN so `meta.tags` (the `Ref<Tag>` schema) and this type stay in sync.
-  makeObject(TagTypeDXN)
-);
+}).pipe(LabelAnnotation.set([
+  "label"
+]), HiddenAnnotation.set(true))) {
+};
 var make2 = (props) => make(Tag, props);
 var sortTags = ({ label: a }, { label: b }) => a.localeCompare(b);
 var createTagList = (tags) => Object.entries(tags).map(([id, tag]) => ({
@@ -105,4 +101,4 @@ export {
   findOrCreate,
   Tag_exports
 };
-//# sourceMappingURL=chunk-E7IOTOZD.mjs.map
+//# sourceMappingURL=chunk-42L4HJ3Z.mjs.map

package/dist/lib/neutral/chunk-42L4HJ3Z.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Tag.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\n\nimport type * as Database from './Database';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\nexport class Tag extends Type.makeObject<Tag>(internal.TagTypeDXN)(\n  Schema.Struct({\n    label: Schema.String,\n    hue: Schema.optional(Schema.String), // TODO(burdon): Color name?\n  }).pipe(internal.LabelAnnotation.set(['label']), internal.HiddenAnnotation.set(true)),\n) {}\n\nexport const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);\n\nexport type Map = Record<string, Type.InstanceType<typeof Tag>>;\n\nexport const sortTags = ({ label: a }: Type.InstanceType<typeof Tag>, { label: b }: Type.InstanceType<typeof Tag>) =>\n  a.localeCompare(b);\n\nexport const createTagList = (tags: Map): Type.InstanceType<typeof Tag>[] =>\n  Object.entries(tags)\n    .map(([id, tag]) => ({ ...tag, id }))\n    .sort(sortTags);\n\nexport const findTagByLabel = (tags: Map | undefined, name: string): Type.InstanceType<typeof Tag> | undefined => {\n  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());\n  return entry ? { ...entry[1], id: entry[0] } : undefined;\n};\n\n/**\n * Finds or creates a {@link Tag} object in the database.\n *\n * - With a foreign `key` (system/provider tags): matched by that key; the label is kept current on\n *   re-sync. Use a stable key (e.g. `{ source: 'google.com/gmail/label', id }`) for tags whose\n *   identity is external or well-known.\n * - Without a key (user tags): matched by case-insensitive label among tags that carry **no**\n *   foreign key, so it never collides with a keyed system/provider tag of the same label.\n */\nexport const findOrCreate = async (\n  db: Pick<Database.Database, 'query' | 'add'>,\n  options: { label: string; hue?: string; key?: ForeignKey },\n): Promise<Type.InstanceType<typeof Tag>> => {\n  const { label, hue, key } = options;\n  const withHue = hue ? { hue } : {};\n  if (key) {\n    const [existing] = await db.query(Filter.foreignKeys(Tag, [key])).run();\n    if (existing) {\n      // Keep label (and hue, when provided) current on re-sync. `hue` is only touched when supplied,\n      // so a label-only re-sync (e.g. Gmail) doesn't wipe a user-set colour.\n      if (existing.label !== label || (hue !== undefined && existing.hue !== hue)) {\n        Obj.update(existing, (existing) => {\n          existing.label = label;\n          if (hue !== undefined) {\n            existing.hue = hue;\n          }\n        });\n      }\n      return existing;\n    }\n\n    return db.add(Obj.make(Tag, { [Obj.Meta]: { keys: [key] }, label, ...withHue }));\n  }\n\n  const lowered = label.toLowerCase();\n  const candidates = await db.query(Filter.type(Tag)).run();\n  const existing = candidates.find(\n    (tag) => tag.label.toLowerCase() === lowered && (Obj.getMeta(tag).keys ?? []).length === 0,\n  );\n  return existing ?? db.add(make({ label, ...withHue }));\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;cAAAA;EAAA;;AAMA,YAAYC,YAAY;AAUjB,IAAMC,MAAN,cAAuBC,WAAyBC,UAAU,EACxDC,cAAO;EACZC,OAAcC;EACdC,KAAYC,gBAAgBF,aAAM;AACpC,CAAA,EAAGG,KAAcC,gBAAgBC,IAAI;EAAC;CAAQ,GAAYC,iBAAiBD,IAAI,IAAA,CAAA,CAAA,EAAA;AAC9E;AAEI,IAAME,QAAO,CAACC,UAAyCD,KAAKZ,KAAKa,KAAAA;AAIjE,IAAMC,WAAW,CAAC,EAAEV,OAAOW,EAAC,GAAmC,EAAEX,OAAOY,EAAC,MAC9ED,EAAEE,cAAcD,CAAAA;AAEX,IAAME,gBAAgB,CAACC,SAC5BC,OAAOC,QAAQF,IAAAA,EACZG,IAAI,CAAC,CAACC,IAAIC,GAAAA,OAAU;EAAE,GAAGA;EAAKD;AAAG,EAAA,EACjCE,KAAKX,QAAAA;AAEH,IAAMY,iBAAiB,CAACP,MAAuBQ,SAAAA;AACpD,QAAMC,QAAQR,OAAOC,QAAQF,QAAQ,CAAC,CAAA,EAAGU,KAAK,CAAC,CAACC,GAAGN,GAAAA,MAASA,IAAIpB,MAAM2B,YAAW,MAAOJ,KAAKI,YAAW,CAAA;AACxG,SAAOH,QAAQ;IAAE,GAAGA,MAAM,CAAA;IAAIL,IAAIK,MAAM,CAAA;EAAG,IAAII;AACjD;AAWO,IAAMC,eAAe,OAC1BC,IACAC,YAAAA;AAEA,QAAM,EAAE/B,OAAOE,KAAK8B,IAAG,IAAKD;AAC5B,QAAME,UAAU/B,MAAM;IAAEA;EAAI,IAAI,CAAC;AACjC,MAAI8B,KAAK;AACP,UAAM,CAACE,SAAAA,IAAY,MAAMJ,GAAGK,MAAaC,YAAYxC,KAAK;MAACoC;KAAI,CAAA,EAAGK,IAAG;AACrE,QAAIH,WAAU;AAGZ,UAAIA,UAASlC,UAAUA,SAAUE,QAAQ0B,UAAaM,UAAShC,QAAQA,KAAM;AAC3EoC,QAAIC,OAAOL,WAAU,CAACA,cAAAA;AACpBA,UAAAA,UAASlC,QAAQA;AACjB,cAAIE,QAAQ0B,QAAW;AACrBM,YAAAA,UAAShC,MAAMA;UACjB;QACF,CAAA;MACF;AACA,aAAOgC;IACT;AAEA,WAAOJ,GAAGU,IAAQhC,KAAKZ,KAAK;MAAE,CAAK6C,IAAI,GAAG;QAAEC,MAAM;UAACV;;MAAK;MAAGhC;MAAO,GAAGiC;IAAQ,CAAA,CAAA;EAC/E;AAEA,QAAMU,UAAU3C,MAAM2B,YAAW;AACjC,QAAMiB,aAAa,MAAMd,GAAGK,MAAaU,KAAKjD,GAAAA,CAAAA,EAAMyC,IAAG;AACvD,QAAMH,WAAWU,WAAWnB,KAC1B,CAACL,QAAQA,IAAIpB,MAAM2B,YAAW,MAAOgB,YAAgBG,QAAQ1B,GAAAA,EAAKsB,QAAQ,CAAA,GAAIK,WAAW,CAAA;AAE3F,SAAOb,YAAYJ,GAAGU,IAAIhC,MAAK;IAAER;IAAO,GAAGiC;EAAQ,CAAA,CAAA;AACrD;",
+  "names": ["make", "Schema", "Tag", "makeObject", "TagTypeDXN", "Struct", "label", "String", "hue", "optional", "pipe", "LabelAnnotation", "set", "HiddenAnnotation", "make", "props", "sortTags", "a", "b", "localeCompare", "createTagList", "tags", "Object", "entries", "map", "id", "tag", "sort", "findTagByLabel", "name", "entry", "find", "_", "toLowerCase", "undefined", "findOrCreate", "db", "options", "key", "withHue", "existing", "query", "foreignKeys", "run", "Obj", "update", "add", "Meta", "keys", "lowered", "candidates", "type", "getMeta", "length"]
+}

package/dist/lib/neutral/{chunk-K3S7D5PR.mjs → chunk-4A2NWKRJ.mjs}

@@ -3,17 +3,17 @@ import {
   FormatAnnotation,
   FormatAnnotationId,
   TypeFormat
-} from "./chunk-TFEWTY5A.mjs";
+} from "./chunk-KCBW4BR6.mjs";
 import {
   createEchoReferenceSchema
-} from "./chunk-4TPQZPLY.mjs";
+} from "./chunk-L3E5IXAE.mjs";
 import {
   GeneratorAnnotationId,
   LabelAnnotationId,
   PropertyMetaAnnotationId,
   TypeAnnotationId,
   TypeIdentifierAnnotationId
-} from "./chunk-WZ32BF53.mjs";
+} from "./chunk-3TN2VMI4.mjs";
 import {
   ANY_OBJECT_TYPENAME,
   ANY_OBJECT_VERSION,
@@ -21,7 +21,7 @@ import {
   EntityKindSchema,
   getStaticTypeSchema,
   makeTypeJsonSchemaAnnotation
-} from "./chunk-O6BH7EPN.mjs";
+} from "./chunk-2ZHECXUR.mjs";
 
 // src/internal/JsonSchema/annotations.ts
 import * as SchemaAST from "effect/SchemaAST";
@@ -744,4 +744,4 @@ export {
   toJsonSchema,
   toEffectSchema
 };
-//# sourceMappingURL=chunk-K3S7D5PR.mjs.map
+//# sourceMappingURL=chunk-4A2NWKRJ.mjs.map