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

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Query.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as EffectArray from 'effect/Array';\nimport type * as Schema from 'effect/Schema';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nimport type * as Collection from './Collection';\nimport * as Database from './Database';\nimport type * as Dataset from './Dataset';\nimport * as Feed from './Feed';\nimport * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Order from './Order';\nimport type * as Ref from './Ref';\nimport type * as Relation from './Relation';\nimport type * as View from './View';\n\n// TODO(dmaretskyi): Split up into interfaces for objects and relations so they can have separate verbs.\n// TODO(dmaretskyi): Undirected relation traversals.\n// TODO(wittjosiah): Make Filter & Query pipeable.\n\n/**\n * All property paths inside T that are references.\n */\n// TODO(dmaretskyi): Filter only properties that are references (or optional references, or unions that include references).\ntype RefPropKey<T> = keyof T & string;\n\n// TODO(burdon): Narrow T to Entity.Unknown?\nexport interface Query<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Query': { value: T };\n\n  ast: QueryAST.Query;\n\n  /**\n   * Filter the current selection based on a filter.\n   * @param filter - Filter to select the objects.\n   * @returns Query for the selected objects.\n   */\n  'select'(filter: Filter.Filter<T>): Query<T>;\n  'select'(props: Filter.Props<T>): Query<T>;\n\n  /**\n   * Traverse an outgoing reference.\n   * @param key - Property path inside T that is a reference or optional reference.\n   * @returns Query for the target of the reference.\n   */\n  'reference'<K extends RefPropKey<T>>(\n    key: K,\n  ): Query<\n    T[K] extends Ref.Unknown\n      ? Ref.Target<T[K]>\n      : T[K] extends Ref.Unknown | undefined\n        ? Ref.Target<Exclude<T[K], undefined>>\n        : never\n  >;\n\n  /**\n   * Find objects referencing this object.\n   * @param target - Schema of the referencing object. If not provided, matches any type.\n   * @param key - Property path inside the referencing object that is a reference. If not provided, matches any property.\n   * @returns Query for the referencing objects.\n   */\n  // TODO(dmaretskyi): any way to enforce `Ref.Target<Schema.Schema.Type<S>[key]> == T`?\n  // TODO(dmaretskyi): Ability to go through arrays of references.\n  'referencedBy'<S extends Schema.Schema.All>(\n    target: S | string,\n    key: RefPropKey<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n  'referencedBy'<S extends Schema.Schema.All>(target: S | string): Query<Schema.Schema.Type<S>>;\n  'referencedBy'(): Query<any>;\n\n  /**\n   * Find relations where this object is the source.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  'sourceOf'<S extends Schema.Schema.All>(\n    relation?: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * Find relations where this object is the target.\n   * @returns Query for the relation objects.\n   * @param relation - Schema of the relation.\n   * @param predicates - Predicates to filter the relation objects.\n   */\n  'targetOf'<S extends Schema.Schema.All>(\n    relation?: S | string,\n    predicates?: Filter.Props<Schema.Schema.Type<S>>,\n  ): Query<Schema.Schema.Type<S>>;\n\n  /**\n   * For a query for relations, get the source objects.\n   * @returns Query for the source objects.\n   */\n  'source'(): Query<Relation.SourceOf<T>>;\n\n  /**\n   * For a query for relations, get the target objects.\n   * @returns Query for the target objects.\n   */\n  'target'(): Query<Relation.TargetOf<T>>;\n\n  /**\n   * Get the parent object of the current selection.\n   * @returns Query for the parent objects.\n   */\n  'parent'(): Query<any>;\n\n  /**\n   * Get all child objects of the current selection.\n   * @returns Query for the child objects.\n   */\n  'children'(): Query<any>;\n\n  /**\n   * Order the query results.\n   * Orders are specified in priority order. The first order will be applied first, etc.\n   * @param order - Order to sort the results.\n   * @returns Query for the ordered results.\n   */\n  'orderBy'(...order: EffectArray.NonEmptyArray<Order.Order<T>>): Query<T>;\n\n  /**\n   * Limit the number of results.\n   * @param limit - Maximum number of results to return.\n   * @returns Query for the limited results.\n   */\n  'limit'(limit: number): Query<T>;\n\n  /**\n   * Query from selected databases only.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from(db);\n   * ```\n   *\n   * @param options.includeFeeds [false] - Whether to include feeds in the query. Default is to query from automerge documents only.\n   */\n  'from'(database: Database.Database | Database.Database[], options?: { includeFeeds?: boolean }): Query<T>;\n\n  /**\n   * Query from selected feeds only.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from(feed);\n   * ```\n   *\n   */\n  'from'(feeds: Feed.Feed | Feed.Feed[]): Query<T>;\n\n  /**\n   * Query from all accessible spaces.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.type(Person)).from('all-accessible-spaces');\n   * ```\n   *\n   * @param options.includeFeeds [false] - Whether to include feeds in the query. Default is to query from automerge documents only.\n   */\n  'from'(allSpaces: 'all-accessible-spaces', options?: { includeFeeds?: boolean }): Query<T>;\n\n  /**\n   * Query from a dataset.\n   * Currently only feeds are supported.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.type(Person).from(feed);\n   * ```\n   */\n  'from'(dataset: Dataset.Dataset): Query<T>;\n\n  /**\n   * Query from the results of another query.\n   *\n   * Example:\n   *\n   * ```ts\n   * Query.select(Filter.props({ foo: 'foo' })).from(Query.select(Filter.type(Contact)).reference('org'));\n   * ```\n   */\n  'from'(query: Any): Query<T>;\n\n  /**\n   * Query from a raw scope specification.\n   */\n  'from'(scope: QueryAST.Scope): Query<T>;\n\n  /**\n   * Add options to a query.\n   */\n  'options'(options: QueryAST.QueryOptions): Query<T>;\n}\n\nexport type Any = Query<any>;\n\nexport type Type<Q extends Any> = Q extends Query<infer T> ? T : never;\n\nclass QueryClass implements Any {\n  private static 'variance': Any['~Query'] = {} as Any['~Query'];\n\n  constructor(public readonly ast: QueryAST.Query) {}\n\n  '~Query' = QueryClass.variance;\n\n  select(filter: Filter.Any | Filter.Props<any>): Any {\n    if (Filter.is(filter)) {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: filter.ast,\n      });\n    } else {\n      return new QueryClass({\n        type: 'filter',\n        selection: this.ast,\n        filter: Filter.props(filter).ast,\n      });\n    }\n  }\n\n  reference(key: string): Any {\n    return new QueryClass({\n      type: 'reference-traversal',\n      anchor: this.ast,\n      property: key,\n    });\n  }\n\n  referencedBy(target?: Schema.Schema.All | string, key?: string): Any {\n    const dxn = target !== undefined ? internal.getTypeDXNFromSpecifier(target) : null;\n    return new QueryClass({\n      type: 'incoming-references',\n      anchor: this.ast,\n      property: key ?? null,\n      typename: dxn?.toString() ?? null,\n    });\n  }\n\n  sourceOf(relation?: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'outgoing',\n      filter: relation !== undefined ? Filter.type(relation, predicates).ast : undefined,\n    });\n  }\n\n  targetOf(relation?: Schema.Schema.All | string, predicates?: Filter.Props<unknown> | undefined): Any {\n    return new QueryClass({\n      type: 'relation',\n      anchor: this.ast,\n      direction: 'incoming',\n      filter: relation !== undefined ? Filter.type(relation, predicates).ast : undefined,\n    });\n  }\n\n  source(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'source',\n    });\n  }\n\n  target(): Any {\n    return new QueryClass({\n      type: 'relation-traversal',\n      anchor: this.ast,\n      direction: 'target',\n    });\n  }\n\n  parent(): Any {\n    return new QueryClass({\n      type: 'hierarchy-traversal',\n      anchor: this.ast,\n      direction: 'to-parent',\n    });\n  }\n\n  children(): Any {\n    return new QueryClass({\n      type: 'hierarchy-traversal',\n      anchor: this.ast,\n      direction: 'to-children',\n    });\n  }\n\n  orderBy(...order: Order.Order<any>[]): Any {\n    return new QueryClass({\n      type: 'order',\n      query: this.ast,\n      order: order.map((o) => o.ast),\n    });\n  }\n\n  limit(limit: number): Any {\n    return new QueryClass({\n      type: 'limit',\n      query: this.ast,\n      limit,\n    });\n  }\n\n  from(\n    arg:\n      | Database.Database\n      | Database.Database[]\n      | Feed.Feed\n      | Feed.Feed[]\n      | Collection.Collection\n      | View.View\n      | Any\n      | QueryAST.Scope\n      | 'all-accessible-spaces',\n    options?: { includeFeeds?: boolean },\n  ): Any {\n    if (is(arg)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'query', query: arg.ast },\n      });\n    }\n\n    if (arg === 'all-accessible-spaces') {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: {\n          _tag: 'scope',\n          scope: {\n            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),\n          },\n        },\n      });\n    }\n\n    if (_isScope(arg)) {\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: { _tag: 'scope', scope: arg },\n      });\n    }\n\n    const items = Array.isArray(arg) ? arg : [arg];\n\n    if (items.length > 0 && Database.isDatabase(items[0])) {\n      const databases = items as Database.Database[];\n      return new QueryClass({\n        type: 'from',\n        query: this.ast,\n        from: {\n          _tag: 'scope',\n          scope: {\n            spaceIds: databases.map((db) => db.spaceId),\n            ...(options?.includeFeeds ? { allQueuesFromSpaces: true } : {}),\n          },\n        },\n      });\n    }\n\n    if (items.length > 0) {\n      const typename = Obj.getTypename(items[0] as Obj.Unknown);\n      // TODO(dmaretskyi): Support querying from views.\n      if (typename === 'dxos.org/type/View') {\n        throw new Error('Query.from(view) is not yet supported.');\n      }\n      // TODO(dmaretskyi): Support querying from collections.\n      if (typename === 'dxos.org/type/Collection') {\n        throw new Error('Query.from(collection) is not yet supported.');\n      }\n    }\n\n    const feeds = items as Feed.Feed[];\n    const queueDxns = feeds.flatMap((feed) => {\n      const dxn = Feed.getQueueDxn(feed);\n      return dxn ? [dxn.toString()] : [];\n    });\n    return new QueryClass({\n      type: 'from',\n      query: this.ast,\n      from: {\n        _tag: 'scope',\n        scope: {\n          queues: queueDxns,\n        },\n      },\n    });\n  }\n\n  options(options: QueryAST.QueryOptions): Any {\n    return new QueryClass({\n      type: 'options',\n      query: this.ast,\n      options,\n    });\n  }\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Query' in value;\n};\n\n/** Construct a query from an ast. */\nexport const fromAst = (ast: QueryAST.Query): Any => {\n  return new QueryClass(ast);\n};\n\n/**\n * Select objects based on a filter.\n * @param filter - Filter to select the objects.\n * @returns Query for the selected objects.\n */\nexport const select = <F extends Filter.Any>(filter: F): Query<Filter.Type<F>> => {\n  return new QueryClass({\n    type: 'select',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Query for objects of a given schema.\n * @param schema - Schema of the objects.\n * @param predicates - Predicates to filter the objects.\n * @returns Query for the objects.\n *\n * Shorthand for: `Query.select(Filter.type(schema, predicates))`.\n */\nexport const type = (schema: Schema.Schema.All | string, predicates?: Filter.Props<unknown>): Any => {\n  return new QueryClass({\n    type: 'select',\n    filter: Filter.type(schema, predicates).ast,\n  });\n};\n\n/**\n * Combine results of multiple queries.\n * @param queries - Queries to combine.\n * @returns Query for the combined results.\n */\n// TODO(dmaretskyi): Rename to `combine` or `union`.\nexport const all = (...queries: Any[]): Any => {\n  if (queries.length === 0) {\n    throw new TypeError(\n      'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',\n    );\n  }\n  return new QueryClass({\n    type: 'union',\n    queries: queries.map((q) => q.ast),\n  });\n};\n\n/**\n * Subtract one query from another.\n * @param source - Query to subtract from.\n * @param exclude - Query to subtract.\n * @returns Query for the results of the source query minus the results of the exclude query.\n */\nexport const without = <T>(source: Query<T>, exclude: Query<T>): Query<T> => {\n  return new QueryClass({\n    type: 'set-difference',\n    source: source.ast,\n    exclude: exclude.ast,\n  });\n};\n\n/**\n * Create a query scoped to a data source.\n * The returned query selects everything from the source; chain `.select()` to narrow results.\n *\n * @param source - Data source: database, feed, 'all-accessible-spaces', or another query.\n * @returns Query scoped to the given source.\n */\nexport const from = (\n  source:\n    | Database.Database\n    | Database.Database[]\n    | Feed.Feed\n    | Feed.Feed[]\n    | Any\n    | QueryAST.Scope\n    | 'all-accessible-spaces',\n  options?: { includeFeeds?: boolean },\n): Any => {\n  const baseQuery: QueryAST.Query = {\n    type: 'select',\n    filter: Filter.everything().ast,\n  };\n  const wrapper = new QueryClass(baseQuery);\n  return wrapper.from(source as any, options);\n};\n\nconst SCOPE_KEYS = new Set(['spaceIds', 'queues', 'allQueuesFromSpaces']);\n\n/** Detect a raw Scope object (plain object with only Scope-valid keys). */\nconst _isScope = (value: unknown): value is QueryAST.Scope => {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n    return false;\n  }\n  return Object.keys(value).every((key) => SCOPE_KEYS.has(key));\n};\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;YAAAA;EAAA;cAAAC;EAAA;;AAqNA,IAAMC,aAAN,MAAMA,YAAAA;;EACJ,OAAe,aAA4B,CAAC;EAE5C,YAA4BC,KAAqB;SAArBA,MAAAA;EAAsB;EAElD,WAAWD,YAAWE;EAEtBC,OAAOC,QAA6C;AAClD,QAAWC,GAAGD,MAAAA,GAAS;AACrB,aAAO,IAAIJ,YAAW;QACpBM,MAAM;QACNC,WAAW,KAAKN;QAChBG,QAAQA,OAAOH;MACjB,CAAA;IACF,OAAO;AACL,aAAO,IAAID,YAAW;QACpBM,MAAM;QACNC,WAAW,KAAKN;QAChBG,QAAeI,MAAMJ,MAAAA,EAAQH;MAC/B,CAAA;IACF;EACF;EAEAQ,UAAUC,KAAkB;AAC1B,WAAO,IAAIV,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbW,UAAUF;IACZ,CAAA;EACF;EAEAG,aAAaC,QAAqCJ,KAAmB;AACnE,UAAMK,MAAMD,WAAWE,SAAqBC,wBAAwBH,MAAAA,IAAU;AAC9E,WAAO,IAAId,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbW,UAAUF,OAAO;MACjBQ,UAAUH,KAAKI,SAAAA,KAAc;IAC/B,CAAA;EACF;EAEAC,SAASC,UAAuCC,YAAqD;AACnG,WAAO,IAAItB,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbsB,WAAW;MACXnB,QAAQiB,aAAaL,SAAmBV,KAAKe,UAAUC,UAAAA,EAAYrB,MAAMe;IAC3E,CAAA;EACF;EAEAQ,SAASH,UAAuCC,YAAqD;AACnG,WAAO,IAAItB,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbsB,WAAW;MACXnB,QAAQiB,aAAaL,SAAmBV,KAAKe,UAAUC,UAAAA,EAAYrB,MAAMe;IAC3E,CAAA;EACF;EAEAS,SAAc;AACZ,WAAO,IAAIzB,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbsB,WAAW;IACb,CAAA;EACF;EAEAT,SAAc;AACZ,WAAO,IAAId,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbsB,WAAW;IACb,CAAA;EACF;EAEAG,SAAc;AACZ,WAAO,IAAI1B,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbsB,WAAW;IACb,CAAA;EACF;EAEAI,WAAgB;AACd,WAAO,IAAI3B,YAAW;MACpBM,MAAM;MACNK,QAAQ,KAAKV;MACbsB,WAAW;IACb,CAAA;EACF;EAEAK,WAAWC,OAAgC;AACzC,WAAO,IAAI7B,YAAW;MACpBM,MAAM;MACNwB,OAAO,KAAK7B;MACZ4B,OAAOA,MAAME,IAAI,CAACC,MAAMA,EAAE/B,GAAG;IAC/B,CAAA;EACF;EAEAgC,MAAMA,OAAoB;AACxB,WAAO,IAAIjC,YAAW;MACpBM,MAAM;MACNwB,OAAO,KAAK7B;MACZgC;IACF,CAAA;EACF;EAEAC,KACEC,KAUAC,SACK;AACL,QAAI/B,IAAG8B,GAAAA,GAAM;AACX,aAAO,IAAInC,YAAW;QACpBM,MAAM;QACNwB,OAAO,KAAK7B;QACZiC,MAAM;UAAEG,MAAM;UAASP,OAAOK,IAAIlC;QAAI;MACxC,CAAA;IACF;AAEA,QAAIkC,QAAQ,yBAAyB;AACnC,aAAO,IAAInC,YAAW;QACpBM,MAAM;QACNwB,OAAO,KAAK7B;QACZiC,MAAM;UACJG,MAAM;UACNC,OAAO;YACL,GAAIF,SAASG,eAAe;cAAEC,qBAAqB;YAAK,IAAI,CAAC;UAC/D;QACF;MACF,CAAA;IACF;AAEA,QAAIC,SAASN,GAAAA,GAAM;AACjB,aAAO,IAAInC,YAAW;QACpBM,MAAM;QACNwB,OAAO,KAAK7B;QACZiC,MAAM;UAAEG,MAAM;UAASC,OAAOH;QAAI;MACpC,CAAA;IACF;AAEA,UAAMO,QAAQC,MAAMC,QAAQT,GAAAA,IAAOA,MAAM;MAACA;;AAE1C,QAAIO,MAAMG,SAAS,KAAcC,WAAWJ,MAAM,CAAA,CAAE,GAAG;AACrD,YAAMK,YAAYL;AAClB,aAAO,IAAI1C,YAAW;QACpBM,MAAM;QACNwB,OAAO,KAAK7B;QACZiC,MAAM;UACJG,MAAM;UACNC,OAAO;YACLU,UAAUD,UAAUhB,IAAI,CAACkB,OAAOA,GAAGC,OAAO;YAC1C,GAAId,SAASG,eAAe;cAAEC,qBAAqB;YAAK,IAAI,CAAC;UAC/D;QACF;MACF,CAAA;IACF;AAEA,QAAIE,MAAMG,SAAS,GAAG;AACpB,YAAM3B,WAAeiC,YAAYT,MAAM,CAAA,CAAE;AAEzC,UAAIxB,aAAa,sBAAsB;AACrC,cAAM,IAAIkC,MAAM,wCAAA;MAClB;AAEA,UAAIlC,aAAa,4BAA4B;AAC3C,cAAM,IAAIkC,MAAM,8CAAA;MAClB;IACF;AAEA,UAAMC,QAAQX;AACd,UAAMY,YAAYD,MAAME,QAAQ,CAACC,SAAAA;AAC/B,YAAMzC,MAAW0C,YAAYD,IAAAA;AAC7B,aAAOzC,MAAM;QAACA,IAAII,SAAQ;UAAM,CAAA;IAClC,CAAA;AACA,WAAO,IAAInB,YAAW;MACpBM,MAAM;MACNwB,OAAO,KAAK7B;MACZiC,MAAM;QACJG,MAAM;QACNC,OAAO;UACLoB,QAAQJ;QACV;MACF;IACF,CAAA;EACF;EAEAlB,QAAQA,SAAqC;AAC3C,WAAO,IAAIpC,YAAW;MACpBM,MAAM;MACNwB,OAAO,KAAK7B;MACZmC;IACF,CAAA;EACF;AACF;AAEO,IAAM/B,MAAK,CAACsD,UAAAA;AACjB,SAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,YAAYA;AACpE;AAGO,IAAMC,UAAU,CAAC3D,QAAAA;AACtB,SAAO,IAAID,WAAWC,GAAAA;AACxB;AAOO,IAAME,SAAS,CAAuBC,WAAAA;AAC3C,SAAO,IAAIJ,WAAW;IACpBM,MAAM;IACNF,QAAQA,OAAOH;EACjB,CAAA;AACF;AAUO,IAAMK,QAAO,CAACuD,QAAoCvC,eAAAA;AACvD,SAAO,IAAItB,WAAW;IACpBM,MAAM;IACNF,QAAeE,KAAKuD,QAAQvC,UAAAA,EAAYrB;EAC1C,CAAA;AACF;AAQO,IAAM6D,MAAM,IAAIC,YAAAA;AACrB,MAAIA,QAAQlB,WAAW,GAAG;AACxB,UAAM,IAAImB,UACR,4GAAA;EAEJ;AACA,SAAO,IAAIhE,WAAW;IACpBM,MAAM;IACNyD,SAASA,QAAQhC,IAAI,CAACkC,MAAMA,EAAEhE,GAAG;EACnC,CAAA;AACF;AAQO,IAAMiE,UAAU,CAAIzC,QAAkB0C,YAAAA;AAC3C,SAAO,IAAInE,WAAW;IACpBM,MAAM;IACNmB,QAAQA,OAAOxB;IACfkE,SAASA,QAAQlE;EACnB,CAAA;AACF;AASO,IAAMiC,OAAO,CAClBT,QAQAW,YAAAA;AAEA,QAAMgC,YAA4B;IAChC9D,MAAM;IACNF,QAAeiE,WAAU,EAAGpE;EAC9B;AACA,QAAMqE,UAAU,IAAItE,WAAWoE,SAAAA;AAC/B,SAAOE,QAAQpC,KAAKT,QAAeW,OAAAA;AACrC;AAEA,IAAMmC,aAAa,oBAAIC,IAAI;EAAC;EAAY;EAAU;CAAsB;AAGxE,IAAM/B,WAAW,CAACkB,UAAAA;AAChB,MAAI,OAAOA,UAAU,YAAYA,UAAU,QAAQhB,MAAMC,QAAQe,KAAAA,GAAQ;AACvE,WAAO;EACT;AACA,SAAOc,OAAOC,KAAKf,KAAAA,EAAOgB,MAAM,CAACjE,QAAQ6D,WAAWK,IAAIlE,GAAAA,CAAAA;AAC1D;",
-  "names": ["is", "type", "QueryClass", "ast", "variance", "select", "filter", "is", "type", "selection", "props", "reference", "key", "anchor", "property", "referencedBy", "target", "dxn", "undefined", "getTypeDXNFromSpecifier", "typename", "toString", "sourceOf", "relation", "predicates", "direction", "targetOf", "source", "parent", "children", "orderBy", "order", "query", "map", "o", "limit", "from", "arg", "options", "_tag", "scope", "includeFeeds", "allQueuesFromSpaces", "_isScope", "items", "Array", "isArray", "length", "isDatabase", "databases", "spaceIds", "db", "spaceId", "getTypename", "Error", "feeds", "queueDxns", "flatMap", "feed", "getQueueDxn", "queues", "value", "fromAst", "schema", "all", "queries", "TypeError", "q", "without", "exclude", "baseQuery", "everything", "wrapper", "SCOPE_KEYS", "Set", "Object", "keys", "every", "has"]
-}

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

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

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/internal/types/typename.ts", "../../../src/internal/annotations/annotations.ts"],
-  "sourcesContent": ["//\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 * Returns the schema for the given object if one is defined.\n *\n * @internal (Use Obj.getSchema)\n */\n// TODO(burdon): Narrow type.\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// 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 { raise } from '@dxos/debug';\nimport { type JsonPath, getField } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Primitive } from '@dxos/util';\n\nimport { type AnyProperties, EntityKind, TypeId, getSchema } from '../types';\n\nimport { type AnnotationHelper, createAnnotationHelper } from './util';\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 a `dxn: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 DXN of the schema.\n *\n * For non-stored schema returns `dxn:type:`.\n * For stored schema returns `dxn:echo:`.\n */\nexport const getSchemaDXN = (schema: Schema.Schema.All): DXN | undefined => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');\n  const id = getTypeIdentifierAnnotation(schema);\n  if (id) {\n    return DXN.parse(id);\n  }\n\n  // TODO(dmaretskyi): Add support for dynamic schema.\n  const objectAnnotation = getTypeAnnotation(schema);\n  if (!objectAnnotation) {\n    return undefined;\n  }\n\n  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);\n};\n\n/**\n * @param input schema or a typename string.\n * @return type DXN.\n */\nexport const getTypeDXNFromSpecifier = (input: Schema.Schema.All | string): DXN => {\n  if (Schema.isSchema(input)) {\n    return getSchemaDXN(input) ?? raise(new TypeError('Schema has no DXN'));\n  } else {\n    assertArgument(typeof input === 'string', 'input');\n    assertArgument(!input.startsWith('dxn:'), 'input');\n    return DXN.fromTypename(input);\n  }\n};\n\n//\n// TypeAnnotation\n//\n\n/**\n * Fully qualified globally unique typename.\n * Example: `dxos.org/type/Message`\n */\n// TODO(burdon): Reconcile with short DXN format.\n// TODO(burdon): Change \"/type\" => \"/schema\" throughout.\nexport const TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\\w+\\.[a-zA-Z]\\w{1,}\\/[\\w/_-]+$/)).annotations(\n  {\n    description: 'Fully qualified globally unique typename',\n    example: 'dxos.org/type/Message',\n  },\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 \"example.org/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    const type = getTypeDXN(obj);\n    return type?.asTypeDXN()?.type;\n  }\n};\n\n/**\n * @internal (use Type.setTypename)\n */\n// TODO(dmaretskyi): Rename setTypeDXN.\nexport const setTypename = (obj: any, typename: DXN): void => {\n  invariant(typename instanceof DXN, '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 as {@link DXN}.\n * @returns undefined if the object doesn't have a type.\n * @example `dxn:example.com/type/Person:1.0.0`\n *\n * @internal (use Obj.getTypeDXN)\n */\n// TODO(burdon): Narrow type.\nexport const getTypeDXN = (obj: AnyProperties): DXN | undefined => {\n  if (!obj) {\n    return undefined;\n  }\n\n  const type = (obj as any)[TypeId];\n  if (!type) {\n    return undefined;\n  }\n\n  invariant(type instanceof DXN, 'Invalid object.');\n  return type;\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 = <Schema extends Schema.Schema.AnyNoContext>(\n  schema: Schema,\n  object: any,\n): object is Schema.Schema.Type<Schema> => {\n  if (object == null) {\n    return false;\n  }\n\n  const schemaDXN = getSchemaDXN(schema);\n  if (!schemaDXN) {\n    throw new Error('Schema must have an object annotation.');\n  }\n\n  const type = getTypeDXN(object);\n  if (type && DXN.equals(type, schemaDXN)) {\n    return true;\n  }\n\n  const typename = getTypename(object);\n  if (!typename) {\n    return false;\n  }\n\n  const typeDXN = schemaDXN.asTypeDXN();\n  if (!typeDXN) {\n    return false;\n  }\n\n  return typeDXN.type === typename;\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?\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 a schema for a hidden system type.\n */\nexport const SystemTypeAnnotationId = Symbol.for('@dxos/schema/annotation/SystemType');\nexport const SystemTypeAnnotation = createAnnotationHelper<boolean>(SystemTypeAnnotationId);\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 */\n// TODO(burdon): Convert to 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 = getField(object, accessor as 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        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 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 = getField(object, accessor as 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 accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  object[accessor] = 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 */\n// TODO(burdon): UI concern.\nexport const FormInputAnnotationId = Symbol.for('@dxos/schema/annotation/FormInput');\nexport const FormInputAnnotation = createAnnotationHelper<boolean>(FormInputAnnotationId);\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// TODO(wittjosiah): Comment.\nexport const makeUserAnnotation = <T>(props: MakeAnnoationsProps<T>): AnnotationHelper<T> => {\n  assertArgument(\n    /[a-zA-Z0-9]+\\.[a-zA-Z.]+\\/[a-zA-Z/]+/.test(props.id),\n    'id',\n    'Annotation id must be in the FQN format (dxos.org/annotation/Example).',\n  );\n\n  const getFromAst = (ast: SchemaAST.AST) =>\n    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(ast).pipe(\n      Option.map((meta) => meta[props.id] as unknown),\n      Option.map(Schema.decodeUnknownSync(props.schema)),\n    );\n\n  return {\n    get: (schema) => getFromAst(schema.ast),\n    getFromAst: (ast) => getFromAst(ast),\n    set: (value) =>\n      PropertyMeta(props.id, Schema.encodeSync(props.schema)(value)) as <S extends Schema.Schema.Any>(schema: S) => S,\n  };\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\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: 'dxos.org/annotation/Icon',\n  schema: IconAnnotationSchema,\n});\n"],
-  "mappings": "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",
-  "names": ["ATTR_TYPE", "TypeId", "Symbol", "for", "SchemaId", "ATTR_PARENT", "ParentId", "getSchema", "obj", "setSchema", "schema", "Object", "defineProperty", "value", "writable", "enumerable", "configurable", "Function", "Option", "Schema", "SchemaAST", "raise", "getField", "assertArgument", "invariant", "DXN", "FIELD_PATH_ANNOTATION", "FieldPath", "path", "PropertyMeta", "TypeIdentifierAnnotationId", "Symbol", "for", "getTypeIdentifierAnnotation", "schema", "flow", "getAnnotation", "getOrElse", "undefined", "ast", "getSchemaDXN", "assertArgument", "isSchema", "id", "DXN", "parse", "objectAnnotation", "getTypeAnnotation", "fromTypenameAndVersion", "typename", "version", "getTypeDXNFromSpecifier", "input", "raise", "TypeError", "startsWith", "fromTypename", "TypenameSchema", "String", "pipe", "pattern", "annotations", "description", "example", "VersionSchema", "TypeMeta", "Struct", "TypeAnnotationId", "TypeAnnotation", "extend", "kind", "Enums", "EntityKind", "sourceSchema", "optional", "Schema", "targetSchema", "getEntityKind", "getSchemaTypename", "getSchemaVersion", "getTypename", "obj", "getSchema", "type", "getTypeDXN", "asTypeDXN", "setTypename", "invariant", "Object", "defineProperty", "TypeId", "value", "writable", "enumerable", "configurable", "isInstanceOf", "object", "schemaDXN", "Error", "equals", "typeDXN", "PropertyMetaAnnotationId", "name", "self", "existingMeta", "getPropertyMetaAnnotation", "prop", "map", "meta", "ReferenceAnnotationId", "ReferenceAnnotation", "createAnnotationHelper", "SchemaMetaSymbol", "SystemTypeAnnotationId", "SystemTypeAnnotation", "LabelAnnotationId", "LabelAnnotation", "getLabelWithSchema", "annotation", "get", "accessor", "getField", "toString", "setLabelWithSchema", "label", "field", "DescriptionAnnotationId", "DescriptionAnnotation", "getDescriptionWithSchema", "setDescriptionWithSchema", "FormInputAnnotationId", "FormInputAnnotation", "FieldLookupAnnotationId", "GeneratorAnnotationId", "GeneratorAnnotation", "makeUserAnnotation", "props", "test", "getFromAst", "decodeUnknownSync", "set", "encodeSync", "IconAnnotationSchema", "icon", "hue", "IconAnnotation"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Tag.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport * as Type from './Type';\n\nexport const Tag = Schema.Struct({\n  label: Schema.String,\n  hue: Schema.optional(Schema.String), // TODO(burdon): Color name?\n}).pipe(\n  Type.object({\n    typename: 'dxos.org/type/Tag',\n    version: '0.1.0',\n  }),\n  internal.LabelAnnotation.set(['label']),\n  internal.SystemTypeAnnotation.set(true),\n);\n\nexport type Tag = Schema.Schema.Type<typeof Tag>;\n\nexport const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);\n\nexport type Map = Record<string, Tag>;\n\nexport const sortTags = ({ label: a }: Tag, { label: b }: Tag) => a.localeCompare(b);\n\nexport const createTagList = (tags: Map): Tag[] =>\n  Object.entries(tags)\n    .map(([id, tag]) => ({ ...tag, id }))\n    .sort(sortTags);\n\nexport const findTagByLabel = (tags: Map | undefined, name: string): 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"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;cAAAA;EAAA;;AAIA,YAAYC,YAAY;AAMjB,IAAMC,MAAaC,cAAO;EAC/BC,OAAcC;EACdC,KAAYC,gBAAgBF,aAAM;AACpC,CAAA,EAAGG,KACIC,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,GACSC,gBAAgBC,IAAI;EAAC;CAAQ,GAC7BC,qBAAqBD,IAAI,IAAA,CAAA;AAK7B,IAAME,QAAO,CAACC,UAAyCD,KAAKb,KAAKc,KAAAA;AAIjE,IAAMC,WAAW,CAAC,EAAEb,OAAOc,EAAC,GAAS,EAAEd,OAAOe,EAAC,MAAYD,EAAEE,cAAcD,CAAAA;AAE3E,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,IAAIvB,MAAM8B,YAAW,MAAOJ,KAAKI,YAAW,CAAA;AACxG,SAAOH,QAAQ;IAAE,GAAGA,MAAM,CAAA;IAAIL,IAAIK,MAAM,CAAA;EAAG,IAAII;AACjD;",
-  "names": ["make", "Schema", "Tag", "Struct", "label", "String", "hue", "optional", "pipe", "object", "typename", "version", "LabelAnnotation", "set", "SystemTypeAnnotation", "make", "props", "sortTags", "a", "b", "localeCompare", "createTagList", "tags", "Object", "entries", "map", "id", "tag", "sort", "findTagByLabel", "name", "entry", "find", "_", "toLowerCase", "undefined"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Feed.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport type * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\n\nimport { DXN } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport type * as Filter from './Filter';\nimport * as internal from './internal';\nimport * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport * as Type from './Type';\n\n/**\n * Runtime schema for a Feed object.\n *\n * @example\n * ```ts\n * const feed = Obj.make(Feed.Feed, { name: 'notifications', kind: 'dxos.org/plugin/notifications/v1' });\n * ```\n */\nexport const Feed = Schema.Struct({\n  /** User-facing display name. */\n  name: Schema.String.pipe(Schema.optional),\n  /** Identifier for the feed's kind (e.g., plugin id). */\n  kind: Schema.String.pipe(internal.FormInputAnnotation.set(false), Schema.optional),\n}).pipe(\n  Type.object({\n    typename: 'dxos.org/type/Feed',\n    version: '0.1.0',\n  }),\n);\n\n/**\n * TypeScript instance type for a Feed object.\n */\nexport interface Feed extends Schema.Schema.Type<typeof Feed> {}\n\n//\n// Types\n//\n\n/**\n * Meta key source for storing the backing DXN bound to a feed object.\n */\n// TODO(dmaretskyi): Enforce that Feed ObjectId = feed storage ID. And remove this key.\nexport const DXN_KEY = 'dxos.org/key/feed';\n\n/**\n * Opaque cursor for iterating over feed items.\n */\n// TODO(dmaretskyi): T needs to be referenced in the type structure for typescript to respect it during inference and type-checking.\nexport interface Cursor<T = Obj.Snapshot> {\n  readonly _tag: 'Cursor';\n}\n\n/**\n * Retention options for a feed.\n */\nexport interface RetentionOptions {\n  /** Retain items after this cursor position. */\n  // TODO(wittjosiah): Use FeedCursor from @dxos/feed?\n  cursor?: string;\n}\n\n//\n// Factory\n//\n\n/**\n * Creates a new feed object.\n *\n * @example\n * ```ts\n * const feed = Feed.make({ name: 'notifications', kind: 'dxos.org/plugin/notifications/v1' });\n * ```\n */\n// TODO(wittjosiah): How to control the feed namespace (data/trace)? Why do feeds have namespaces?\nexport const make = (props: Obj.MakeProps<typeof Feed>): Feed => Obj.make(Feed, props);\n\n/**\n * Reads the queue DXN from feed metadata.\n *\n * @deprecated\n */\n// TODO(wittjosiah): Align backing feed dxn's with object DXN.\nexport const getQueueDxn = (feed: Feed): DXN | undefined => {\n  const keys = Obj.getKeys(feed, DXN_KEY);\n  return keys.length === 0 ? undefined : DXN.parse(keys[0].id);\n};\n\n//\n// Service\n//\n\n/**\n * Effect service for feed operations.\n * Provides the bridge to the underlying storage implementation.\n * Must be provided by the application layer (e.g., echo-db).\n */\nexport class Service extends Context.Tag('@dxos/echo/Feed/Service')<\n  Service,\n  {\n    /**\n     * Appends items to a feed.\n     */\n    append(feed: Feed, items: Entity.Unknown[]): Promise<void>;\n\n    /**\n     * Removes items from a feed by ID.\n     */\n    // TODO(dmaretskyi): Change type to ObjectId.\n    remove(feed: Feed, ids: string[]): Promise<void>;\n\n    /**\n     * Queries items in a feed.\n     */\n    query: {\n      <Q extends Query.Any>(feed: Feed, query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n      <F extends Filter.Any>(feed: Feed, filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n    };\n  }\n>() {}\n\n/**\n * Layer that provides a Feed service that throws when accessed.\n * Useful as a default layer when no feed service is available.\n */\nexport const notAvailable: Layer.Layer<Service> = Layer.succeed(Service, {\n  append: () => {\n    throw new Error('Feed.Service not available');\n  },\n  remove: () => {\n    throw new Error('Feed.Service not available');\n  },\n  query: () => {\n    throw new Error('Feed.Service not available');\n  },\n} as Context.Tag.Service<Service>);\n\n//\n// Operations\n//\n\n/**\n * Appends items to a feed.\n *\n * @example\n * ```ts\n * yield* Feed.append(feed, [Obj.make(Notification, { title: 'Hello' })]);\n * ```\n */\nexport const append = (feed: Feed, items: Entity.Unknown[]): Effect.Effect<void, never, Service> =>\n  Effect.gen(function* () {\n    const service = yield* Service;\n    yield* Effect.promise(() => service.append(feed, items));\n  });\n\n/**\n * Removes items from a feed.\n *\n * @example\n * ```ts\n * yield* Feed.remove(feed, [item]);\n * ```\n */\n// TODO(dmaretskyi): Should we allow snapshots here? - what does it mean to remove a snapshot?\nexport const remove = (feed: Feed, items: (Entity.Unknown | Obj.Snapshot)[]): Effect.Effect<void, never, Service> =>\n  Effect.gen(function* () {\n    const service = yield* Service;\n    const ids = items.map((item) => item.id);\n    yield* Effect.promise(() => service.remove(feed, ids));\n  });\n\n/**\n * Creates a reactive query over items in a feed.\n *\n * @example\n * ```ts\n * const result = yield* Feed.query(feed, Filter.type(Person));\n * ```\n */\n// TODO(dmaretskyi): Suport chained queries:\n//                   const result = yield* feed.pipe(Feed.query(Filter.type(Person))); result.subscribe(...)\n//                   const objects = yield* feed.pipe(Feed.query(Filter.type(Person))).run;\n//                   const object = yield* feed.pipe(Feed.query(Filter.type(Person))).first;\n// ... unify for Database and schema queries.\nexport const query: {\n  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  Service.pipe(Effect.map((service) => service.query(feed, queryOrFilter as any) as QueryResult.QueryResult<any>));\n\n/**\n * Executes a feed query once and returns the results.\n *\n * @example\n * ```ts\n * const items = yield* Feed.runQuery(feed, Filter.type(Person));\n * ```\n */\nexport const runQuery: {\n  <Q extends Query.Any>(feed: Feed, query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(feed: Feed, filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (feed: Feed, queryOrFilter: Query.Any | Filter.Any) =>\n  query(feed, queryOrFilter as any).pipe(Effect.flatMap((queryResult) => Effect.promise(() => queryResult.run())));\n\n/**\n * Creates a cursor for iterating over feed items.\n * Currently stubbed — cursor operations are not yet implemented.\n *\n * @example\n * ```ts\n * const cursor = yield* Feed.cursor<Person>(feed);\n * const item = yield* Feed.next(cursor);\n * ```\n */\n// TODO(wittjosiah): Implement cursor operations. Use Effect streams?\nexport const cursor = <T = Obj.Snapshot>(_feed: Feed): Effect.Effect<Cursor<T>, never, Service> =>\n  Effect.succeed({ _tag: 'Cursor' } as Cursor<T>);\n\n/**\n * Returns the next item from a feed cursor.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const next = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<T, never, Service> =>\n  Effect.die('Feed.next is not yet implemented');\n\n/**\n * Returns the next item from a feed cursor as an Option.\n * Currently stubbed — cursor operations are not yet implemented.\n */\nexport const nextOption = <T = Obj.Snapshot>(_cursor: Cursor<T>): Effect.Effect<Option.Option<T>, never, Service> =>\n  Effect.die('Feed.nextOption is not yet implemented');\n\n/**\n * Sets the local retention policy for a feed.\n * Currently stubbed — queues do not yet support retention.\n *\n * @example\n * ```ts\n * yield* Feed.setRetention(feed, { count: 1000 });\n * ```\n */\n// TODO(feed): Implement when queue retention is supported.\nexport const setRetention = (_feed: Feed, _options: RetentionOptions): Effect.Effect<void, never, Service> =>\n  Effect.void;\n"],
-  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;;;;cAAAA;EAAA;;;;;;;;AAIA,YAAYC,aAAa;AACzB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AAEvB,YAAYC,YAAY;AAExB,SAASC,WAAW;AAkBb,IAAMC,OAAcC,cAAO;;EAEhCC,MAAaC,cAAOC,KAAYC,eAAQ;;EAExCC,MAAaH,cAAOC,KAAcG,oBAAoBC,IAAI,KAAA,GAAeH,eAAQ;AACnF,CAAA,EAAGD,KACIK,OAAO;EACVC,UAAU;EACVC,SAAS;AACX,CAAA,CAAA;AAgBK,IAAMC,UAAU;AAgChB,IAAMC,QAAO,CAACC,UAAgDD,KAAKb,MAAMc,KAAAA;AAQzE,IAAMC,cAAc,CAACC,SAAAA;AAC1B,QAAMC,OAAWC,QAAQF,MAAMJ,OAAAA;AAC/B,SAAOK,KAAKE,WAAW,IAAIC,SAAYC,IAAIC,MAAML,KAAK,CAAA,EAAGM,EAAE;AAC7D;AAWO,IAAMC,UAAN,cAA8BC,YAAI,yBAAA,EAAA,EAAA;AAsBpC;AAME,IAAMC,eAA2CC,cAAQH,SAAS;EACvEI,QAAQ,MAAA;AACN,UAAM,IAAIC,MAAM,4BAAA;EAClB;EACAC,QAAQ,MAAA;AACN,UAAM,IAAID,MAAM,4BAAA;EAClB;EACAE,OAAO,MAAA;AACL,UAAM,IAAIF,MAAM,4BAAA;EAClB;AACF,CAAA;AAcO,IAAMD,SAAS,CAACZ,MAAYgB,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOV;AACvB,SAAcW,eAAQ,MAAMD,QAAQN,OAAOZ,MAAMgB,KAAAA,CAAAA;AACnD,CAAA;AAWK,IAAMF,SAAS,CAACd,MAAYgB,UAC1BC,WAAI,aAAA;AACT,QAAMC,UAAU,OAAOV;AACvB,QAAMY,MAAMJ,MAAMK,IAAI,CAACC,SAASA,KAAKf,EAAE;AACvC,SAAcY,eAAQ,MAAMD,QAAQJ,OAAOd,MAAMoB,GAAAA,CAAAA;AACnD,CAAA;AAeK,IAAML,QAGT,CAACf,MAAYuB,kBACff,QAAQpB,KAAYiC,WAAI,CAACH,YAAYA,QAAQH,MAAMf,MAAMuB,aAAAA,CAAAA,CAAAA;AAUpD,IAAMC,WAGT,CAACxB,MAAYuB,kBACfR,MAAMf,MAAMuB,aAAAA,EAAsBnC,KAAYqC,eAAQ,CAACC,gBAAuBP,eAAQ,MAAMO,YAAYC,IAAG,CAAA,CAAA,CAAA;AAatG,IAAMC,SAAS,CAAmBC,UAChClB,eAAQ;EAAEmB,MAAM;AAAS,CAAA;AAM3B,IAAMC,OAAO,CAAmBC,YAC9BC,WAAI,kCAAA;AAMN,IAAMC,aAAa,CAAmBF,YACpCC,WAAI,wCAAA;AAYN,IAAME,eAAe,CAACN,OAAaO,aACjCC;",
-  "names": ["make", "Context", "Effect", "Layer", "Schema", "DXN", "Feed", "Struct", "name", "String", "pipe", "optional", "kind", "FormInputAnnotation", "set", "object", "typename", "version", "DXN_KEY", "make", "props", "getQueueDxn", "feed", "keys", "getKeys", "length", "undefined", "DXN", "parse", "id", "Service", "Tag", "notAvailable", "succeed", "append", "Error", "remove", "query", "items", "gen", "service", "promise", "ids", "map", "item", "queryOrFilter", "runQuery", "flatMap", "queryResult", "run", "cursor", "_feed", "_tag", "next", "_cursor", "die", "nextOption", "setRetention", "_options", "void"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Obj.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath } from '@dxos/effect';\nimport { assertArgument } from '@dxos/invariant';\nimport { type DXN, ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as Err from './Err';\nimport * as internal from './internal';\nimport type * as Ref from './Ref';\nimport type * as Type from './Type';\n\n/**\n * Base type for all ECHO objects.\n */\ninterface BaseObj extends internal.AnyEntity, Entity.OfKind<typeof Entity.Kind.Object> {}\n\n/**\n * Object type with specific properties.\n */\nexport type OfShape<Props> = BaseObj & Props;\n\n/**\n * Object with no known properties beyond id and kind.\n * Use this when the object's schema/properties are not known.\n * For objects with arbitrary properties, use `Obj.AnyProps`.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO object, use `Schema.is(Type.Obj)`.\n */\nexport interface Unknown extends BaseObj {}\n\n/**\n * Runtime Effect schema for any ECHO object.\n * Use for validation, parsing, or as a reference target for collections.\n *\n * NOTE: `Schema.is(Type.Obj)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Obj.isObject()` for proper ECHO instance type guards that check the KindId brand.\n *\n * @example\n * ```ts\n * // Structural type guard (accepts any object with id field)\n * if (Schema.is(Type.Obj)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Obj.isObject(unknownValue)) { ... }\n *\n * // Reference to any object type\n * const Collection = Schema.Struct({\n *   objects: Schema.Array(Ref.Ref(Obj.Unknown)),\n * }).pipe(Type.object({ typename: 'Collection', version: '0.1.0' }));\n * ```\n */\n// TODO(wittjosiah): Investigate if Schema.filter can validate KindId on ECHO instances.\n//   Effect Schema normalizes proxy objects to plain objects before calling filter predicates.\n//   Possible approaches: custom Schema.declare, AST manipulation, or upstream contribution.\nexport const Unknown: Type.Obj<Unknown> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  // TODO(dmaretskyi): Clean this up.\n  // NOTE: The EchoObjectSchema annotation is required for Ref.Ref(Obj.Unknown) to work.\n  //   The typename/version only satisfy ECHO schema machinery for reference targets.\n  internal.EchoObjectSchema({ typename: internal.ANY_OBJECT_TYPENAME, version: internal.ANY_OBJECT_VERSION }),\n  (schema) =>\n    Object.assign(schema, {\n      [internal.SchemaKindId]: (schema as any)[internal.SchemaKindId],\n    }) as unknown as Type.Obj<Unknown>,\n);\n\n/**\n\n/**\n * Object with arbitrary properties.\n *\n * NOTE: Due to how TypeScript works, this type is not assignable to a specific schema type.\n * In that case, use `Obj.instanceOf` to check if an object is of a specific type.\n *\n * Prefer using `Obj.Unknown` when you don't need to access arbitrary properties.\n */\nexport interface Any extends BaseObj, internal.AnyProperties {}\n\n/**\n * Base type for snapshot objects (has SnapshotKindId instead of KindId).\n */\ninterface BaseSnapshot extends internal.AnyEntity {\n  readonly [Entity.SnapshotKindId]: typeof Entity.Kind.Object;\n  readonly id: ObjectId;\n}\n\n/**\n * Immutable snapshot of an ECHO object.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks like useObject().\n *\n * Snapshots are structurally identical to reactive objects but have a different brand,\n * making them distinguishable at the TypeScript level. Neither is assignable to the other.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> & BaseSnapshot;\n\n/**\n * JSON-encoded properties for objects.\n */\nexport interface BaseObjJson {\n  id: string;\n}\n\nconst defaultMeta: internal.ObjectMeta = {\n  keys: [],\n};\n\ntype MakePropsInternal<T extends Unknown> = {\n  id?: ObjectId;\n  [Meta]?: Partial<internal.ObjectMeta>;\n} & Entity.Properties<T>;\n\n// TODO(burdon): Should we allow the caller to set the id?\n/**\n * Props type for object creation with a given schema.\n */\nexport type MakeProps<S extends Schema.Schema.AnyNoContext> = {\n  id?: ObjectId;\n  [Meta]?: Partial<internal.ObjectMeta>;\n  [Parent]?: Unknown;\n} & MakePropsInternal<Schema.Schema.Type<S>>;\n\n/**\n * Creates a new echo object of the given schema.\n * @param schema - Object schema.\n * @param props - Object properties.\n * @param meta - Object metadata (deprecated) -- pass with Obj.Meta.\n *\n * Meta can be passed as a symbol in `props`.\n *\n * Example:\n * ```ts\n * const obj = Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' });\n * ```\n *\n * Note: Only accepts object schemas, not relation schemas. Use `Relation.make` for relations.\n */\nexport const make = <S extends Type.AnyObj>(\n  schema: S,\n  props: NoInfer<MakeProps<S>>,\n): OfShape<Schema.Schema.Type<S>> => {\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === Entity.Kind.Object,\n    'schema',\n    'Expected an object schema',\n  );\n\n  let meta: internal.ObjectMeta | undefined = undefined;\n\n  // Set default fields on meta on creation.\n  if (props[internal.MetaId] != null) {\n    meta = { ...structuredClone(defaultMeta), ...props[internal.MetaId] };\n    delete props[internal.MetaId];\n  }\n\n  // Filter undefined values (Object.entries only returns string-keyed properties).\n  const filterUndefined: any = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== undefined));\n\n  // Copy symbol properties (like ParentId) that Object.entries doesn't include.\n  for (const sym of Object.getOwnPropertySymbols(props)) {\n    const value = (props as any)[sym];\n    if (value !== undefined) {\n      filterUndefined[sym] = value;\n    }\n  }\n\n  return internal.makeObject<Schema.Schema.Type<S>>(schema, filterUndefined as any, {\n    ...defaultMeta,\n    ...meta,\n  });\n};\n\n/**\n * Determine if object is an ECHO object.\n */\nexport const isObject = (obj: unknown): obj is Unknown => {\n  assumeType<internal.InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && obj[Entity.KindId] === Entity.Kind.Object;\n};\n\nexport const isSnapshot = (obj: unknown): obj is Snapshot => {\n  assumeType<internal.InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && (obj as any)[Entity.SnapshotKindId] === Entity.Kind.Object;\n};\n\n/**\n * Subscribe to object updates.\n * The callback is called synchronously when the object is modified.\n * Only accepts reactive objects (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (obj: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(obj, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of an object.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive object at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(obj: T) => Snapshot<T> = internal.getSnapshot as any;\n\n/**\n * Returns the reactive version of an object from the database, given its snapshot.\n * Inverse of `Obj.getSnapshot`.\n *\n * Uses `Obj.getDatabase` internally to get the database from the snapshot,\n * then resolves the reactive object by ID.\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns Effect that succeeds with the reactive object, or fails with `GetReactiveError`.\n * @example\n * ```ts\n * const snapshot = Obj.getSnapshot(obj);\n * const reactive = Obj.getReactive(snapshot).pipe(\n *   Effect.runSync\n * );\n * ```\n */\nexport const getReactive = <T extends Unknown>(snapshot: Snapshot<T>): Effect.Effect<T, Err.GetReactiveError> =>\n  Effect.gen(function* () {\n    const db = internal.getDatabase(snapshot);\n    if (!db) {\n      return yield* Effect.fail(new Err.GetReactiveError({ reason: 'no-database', snapshotId: snapshot.id }));\n    }\n    const obj = db.getObjectById(snapshot.id);\n    if (!obj) {\n      return yield* Effect.fail(new Err.GetReactiveError({ reason: 'object-not-found', snapshotId: snapshot.id }));\n    }\n    return obj as T;\n  });\n\n/**\n * Like `Obj.getReactive` but returns `Option.none()` instead of failing when the object\n * cannot be resolved (no database, object not found).\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns Effect that succeeds with `Option.some(reactive)` or `Option.none()`.\n */\nexport const getReactiveOption = <T extends Unknown>(snapshot: Snapshot<T>): Effect.Effect<Option.Option<T>, never> =>\n  getReactive(snapshot).pipe(\n    Effect.map(Option.some),\n    Effect.catchAll(() => Effect.succeed(Option.none())),\n  );\n\n/**\n * Synchronous version of `Obj.getReactive`. Returns the reactive object or throws\n * `GetReactiveError` when the object cannot be resolved (no database, object not found).\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns The reactive object.\n * @throws {Err.GetReactiveError} When the object cannot be resolved.\n */\nexport const getReactiveOrThrow = <T extends Unknown>(snapshot: Snapshot<T>): T =>\n  Effect.runSync(getReactive(snapshot));\n\nexport type CloneOptions = {\n  /**\n   * Retain the original object's ID.\n   * @default false\n   */\n  retainId?: boolean;\n\n  /**\n   * Recursively clone referenced objects.\n   * @default false\n   */\n  deep?: boolean;\n};\n\n/**\n * Clones an object or relation.\n * This does not clone referenced objects, only the properties in the object.\n * @returns A new object with the same schema and properties.\n */\nexport const clone: <T extends Unknown>(obj: T, opts?: CloneOptions) => T = internal.clone;\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of an object within `Obj.change`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo object within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Obj.change` will throw\n * an error for echo objects.\n *\n * This function also works with nested objects within echo objects (e.g., Template structs)\n * that are reactive at runtime.\n *\n * @param obj - The echo object to mutate. Use `Relation.change` for relations.\n * @param callback - The callback that performs mutations on the object.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John', age: 25 });\n *\n * // Mutate within Obj.change\n * Obj.change(person, (p) => {\n *   p.name = 'Jane';\n *   p.age = 30;\n * });\n * // ONE notification fires here\n *\n * // Direct mutation throws\n * person.name = 'Bob'; // Error: Cannot modify outside Obj.change()\n * ```\n *\n * Note: Only accepts objects. Use `Relation.change` for relations.\n */\nexport const change = <T extends Unknown>(obj: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(obj, callback);\n};\n\n/**\n * Get a deeply nested property from an object.\n *\n * Similar to lodash.get and getDeep from @dxos/util.\n * This is the complementary function to setValue.\n * Accepts both reactive objects and snapshots.\n *\n * @param obj - The ECHO object to get the property from.\n * @param path - Path to the property (array of keys).\n * @returns The value at the path, or undefined if not found.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, {\n *   name: 'John',\n *   addresses: [{ street: '123 Main St' }]\n * });\n *\n * Obj.getValue(person, ['addresses', 0, 'street']); // '123 Main St'\n * Obj.getValue(person, ['addresses', 1, 'street']); // undefined\n * ```\n */\nexport const getValue = (obj: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return internal.getValue(obj, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on an object, using the object's schema to determine\n * whether to initialize nested data as an empty object or array.\n *\n * Similar to lodash.set and setDeep from @dxos/util, but schema-aware.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n *\n * @param obj - The mutable ECHO object to set the property on.\n * @param path - Path to the property (array of keys).\n * @param value - Value to set.\n * @returns The value that was set.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John' });\n * // Person schema has: addresses: Schema.Array(Address)\n * Obj.change(person, (p) => {\n *   Obj.setValue(p, ['addresses', 0, 'street'], '123 Main St');\n * });\n * // Creates: person.addresses = [{ street: '123 Main St' }]\n * ```\n */\n// TODO(wittjosiah): Compute possible path values + type value based on generic object type.\nexport const setValue: (obj: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  internal.setValue as any;\n\n//\n// Type\n//\n\n// TODO(burdon): To discuss: prefer over ObjectId or Key.ObjectId or Type.ID?\nexport const ID = ObjectId;\nexport type ID = ObjectId;\n\n/**\n * Test if object or relation is an instance of a schema.\n * @example\n * ```ts\n * const john = Obj.make(Person, { name: 'John' });\n * const isPerson = Obj.instanceOf(Person);\n * if (isPerson(john)) {\n *   // john is Person\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Schema.Schema.Type<S>;\n  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Schema.Schema.Type<S>;\n} = ((...args: [schema: Type.AnyEntity, value: unknown] | [schema: Type.AnyEntity]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => internal.isInstanceOf(args[0], entity);\n  }\n\n  return internal.isInstanceOf(args[0], args[1]);\n}) as any;\n\n/**\n * Test if a snapshot is an instance of a schema.\n * Mirrors `instanceOf` but only accepts values branded with SnapshotKindId.\n * Use when the value is known to be a snapshot (e.g. from `getSnapshot` or `useObject`).\n *\n * @example\n * ```ts\n * const snapshot = Obj.getSnapshot(person);\n * if (Obj.snapshotOf(Person, snapshot)) {\n *   // snapshot is Obj.Snapshot<Person>\n * }\n * ```\n */\nexport const snapshotOf: {\n  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Snapshot<Schema.Schema.Type<S>>;\n  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Snapshot<Schema.Schema.Type<S>>;\n} = ((...args: [schema: Type.AnyEntity, value: unknown] | [schema: Type.AnyEntity]) => {\n  const check = (entity: unknown) =>\n    entity != null &&\n    typeof entity === 'object' &&\n    Entity.SnapshotKindId in entity &&\n    internal.isInstanceOf(args[0], entity);\n\n  if (args.length === 1) {\n    return (entity: unknown) => check(entity);\n  }\n\n  return check(args[1]);\n}) as any;\n\n// TODO(dmaretskyi): Allow returning undefined.\n/**\n * Get the DXN of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => {\n  assertArgument(!Schema.isSchema(entity), 'obj', 'Object should not be a schema.');\n  return internal.getDXN(entity);\n};\n\n/**\n * @returns The DXN of the object's type.\n * @example dxn:example.com/type/Person:1.0.0\n */\n// TODO(wittjosiah): Narrow types.\nexport const getTypeDXN: (obj: unknown | undefined) => DXN | undefined = internal.getTypeDXN as any;\n\n/**\n * Get the schema of the object.\n * Returns the branded ECHO schema used to create the object.\n */\n// TODO(wittjosiah): Narrow types.\nexport const getSchema: (obj: unknown | undefined) => Type.AnyEntity | undefined = internal.getSchema as any;\n\n/**\n * @returns The typename of the object's type.\n * Accepts both reactive objects and snapshots.\n * @example `example.com/type/Person`\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the object belongs to.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDatabase = (entity: Entity.Unknown | Entity.Snapshot): Database.Database | undefined =>\n  internal.getDatabase(entity);\n\n//\n// Meta\n//\n\n/**\n * Property that accesses metadata for an entity.\n *\n * Alias for `Entity.Meta`.\n */\nexport const Meta = internal.MetaId;\n\n/**\n * Deeply read-only version of ObjectMeta.\n * Prevents mutation at all nesting levels (e.g., `meta.keys.push()` is a TypeScript error).\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Obj.getMeta` inside an `Obj.change` callback.\n */\nexport type Meta = internal.Meta;\n\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): Allow returning undefined.\n/**\n * Get the metadata for an object.\n * Returns mutable meta when passed a mutable object (inside `Obj.change` callback).\n * Returns read-only meta when passed a regular object or snapshot.\n *\n * @example\n * ```ts\n * // Read-only access outside change callback\n * const meta = Obj.getMeta(person);  // ReadonlyMeta\n *\n * // Mutable access inside change callback\n * Obj.change(person, (p) => {\n *   const meta = Obj.getMeta(p);     // ObjectMeta (mutable)\n *   meta.tags ??= [];\n *   meta.tags.push('important');\n * });\n * ```\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * @returns Foreign keys for the object from the specified source.\n * Accepts both reactive objects and snapshots.\n */\nexport const getKeys: {\n  (entity: Unknown | Snapshot, source: string): ForeignKey[];\n  (source: string): (entity: Unknown | Snapshot) => ForeignKey[];\n} = Function.dual(2, (entity: Unknown | Snapshot, source?: string): ForeignKey[] => internal.getKeys(entity, source!));\n\n/**\n * Delete all keys from the object for the specified source.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => internal.deleteKeys(entity, source);\n\n/**\n * Add a tag to the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the object is deleted.\n * Accepts both reactive objects and snapshots.\n */\n// TODO(dmaretskyi): Default to `false`.\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Set the label of the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the object.\n * Must be called within an `Obj.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  internal.setDescription(entity, description);\n\n/**\n * Symbol to set parent when creating objects with `Obj.make`.\n * @example\n * ```ts\n * Obj.make(TestSchema.Person, {\n *   [Obj.Parent]: parentObject,\n *   name: 'John',\n * })\n * ```\n */\nexport const Parent: unique symbol = internal.ParentId as any;\n\n/**\n * Get the parent of an object.\n * The parent is always loaded together with the object.\n * Only objects are allowed to have a parent\n * @returns The parent object, or undefined if the object has no parent.\n */\nexport const getParent = (entity: Unknown | Snapshot): Unknown | undefined => {\n  assertArgument(isObject(entity), 'Expected an object');\n  assumeType<internal.InternalObjectProps>(entity);\n  return entity[internal.ParentId] as Unknown | undefined;\n};\n\n/**\n * Sets the parent of an object.\n * If a parent (or any transitive parent) is deleted, the object will be deleted.\n * Only objects are allowed to have a parent.\n */\nexport const setParent = (entity: Unknown, parent: Any | undefined) => {\n  assertArgument(isObject(entity), 'Expected an object');\n  assertArgument(parent === undefined || isObject(parent), 'Expected an object');\n  assumeType<internal.InternalObjectProps>(entity);\n  assumeType<internal.InternalObjectProps | undefined>(parent);\n  entity[internal.ParentId] = parent;\n};\n\n//\n// JSON\n//\n\n/**\n * JSON representation of an object.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts object to its JSON representation.\n * Accepts both reactive objects and snapshots.\n *\n * The same algorithm is used when calling the standard `JSON.stringify(obj)` function.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);\n\n/**\n * Creates an object from its json representation, performing schema validation.\n * References and schemas will be resolvable if the `refResolver` is provided.\n *\n * The function must be async to support resolving the schema as well as the relation endpoints.\n *\n * @param options.refResolver - Resolver for references. Produces hydrated references that can be resolved.\n * @param options.dxn - Override object DXN. Changes the result of `Obj.getDXN`.\n */\nexport const fromJSON: (json: unknown, options?: { refResolver?: Ref.Resolver; dxn?: DXN }) => Promise<Unknown> =\n  internal.objectFromJSON as any;\n\n/**\n * Comparator function type for sorting objects.\n * Accepts both reactive objects and snapshots.\n */\nexport type Comparator = internal.Comparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = internal.sortByLabel as Comparator;\nexport const sortByTypename: Comparator = internal.sortByTypename as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => internal.sort(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport const VersionTypeId = internal.VersionTypeId;\nexport type VersionCompareResult = internal.VersionCompareResult;\n\n/**\n * Represent object version.\n * May be backed by Automerge.\n * Objects with no history are not versioned.\n */\nexport type Version = internal.EntityVersion;\n\nexport const isVersion = internal.isVersion;\nexport const versionValid = internal.versionValid;\nexport const compareVersions = internal.compareVersions;\nexport const encodeVersion = internal.encodeVersion;\nexport const decodeVersion = internal.decodeVersion;\n\n/**\n * Returns the version of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n"],
-  "mappings": "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",
-  "names": ["Unknown", "VersionTypeId", "addTag", "change", "clone", "compareVersions", "decodeVersion", "deleteKeys", "encodeVersion", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "versionValid", "Effect", "Function", "Option", "Schema", "createJsonPath", "assertArgument", "ObjectId", "assumeType", "Unknown", "Struct", "id", "String", "pipe", "extend", "Record", "key", "value", "EchoObjectSchema", "typename", "ANY_OBJECT_TYPENAME", "version", "ANY_OBJECT_VERSION", "schema", "Object", "assign", "SchemaKindId", "defaultMeta", "keys", "make", "props", "assertArgument", "getTypeAnnotation", "kind", "Kind", "meta", "undefined", "MetaId", "structuredClone", "filterUndefined", "fromEntries", "entries", "filter", "_", "v", "sym", "getOwnPropertySymbols", "makeObject", "isObject", "obj", "assumeType", "KindId", "isSnapshot", "SnapshotKindId", "subscribe", "callback", "getSnapshot", "getReactive", "snapshot", "gen", "db", "getDatabase", "fail", "GetReactiveError", "reason", "snapshotId", "getObjectById", "getReactiveOption", "map", "some", "catchAll", "succeed", "none", "getReactiveOrThrow", "runSync", "clone", "change", "internal", "getValue", "path", "createJsonPath", "setValue", "ID", "ObjectId", "instanceOf", "args", "length", "entity", "isInstanceOf", "snapshotOf", "check", "getDXN", "isSchema", "getTypeDXN", "getSchema", "getTypename", "Meta", "getMeta", "getMetaChecked", "getKeys", "dual", "source", "deleteKeys", "addTag", "tag", "removeTag", "isDeleted", "getLabel", "setLabel", "label", "getDescription", "setDescription", "description", "Parent", "ParentId", "getParent", "setParent", "parent", "toJSON", "objectToJSON", "fromJSON", "objectFromJSON", "sortByLabel", "sortByTypename", "sort", "comparators", "VersionTypeId", "isVersion", "versionValid", "compareVersions", "encodeVersion", "decodeVersion"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/internal/formats/types.ts", "../../../src/internal/formats/number.ts", "../../../src/internal/formats/object.ts", "../../../src/internal/formats/string.ts", "../../../src/internal/formats/format.ts", "../../../src/internal/formats/date.ts", "../../../src/internal/formats/select.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport type * as JSONSchema from 'effect/JSONSchema';\nimport * as Option from 'effect/Option';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { createAnnotationHelper } from '../annotations';\nimport { type JsonSchemaType } from '../json-schema';\n\n// TODO(burdon): Rename PropertyType.\nexport type ScalarType =\n  | JSONSchema.JsonSchema7Object\n  | JSONSchema.JsonSchema7String\n  | JSONSchema.JsonSchema7Number\n  | JSONSchema.JsonSchema7Boolean\n  | JSONSchema.JsonSchema7Ref;\n\n// TODO(burdon): Rename ValueType and change to disciminated union.\n// export type ValueType = 'array' | 'object' | 'string' | 'number' | 'boolean' | 'ref';\nexport enum TypeEnum {\n  Array = 'array', // TODO(burdon): Remove?\n  Object = 'object',\n  String = 'string',\n  Number = 'number',\n  Boolean = 'boolean',\n  Ref = 'ref',\n}\n\n// TODO(burdon): Ref?\nexport const getTypeEnum = (property: JsonSchemaType): TypeEnum | undefined => {\n  switch (property.type) {\n    case 'array':\n      return TypeEnum.Array;\n    case 'object':\n      return TypeEnum.Object;\n    case 'string':\n      return TypeEnum.String;\n    case 'number':\n      return TypeEnum.Number;\n    case 'boolean':\n      return TypeEnum.Boolean;\n    default:\n      return undefined;\n  }\n};\n\n/**\n * https://json-schema.org/understanding-json-schema/reference/schema\n * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats\n */\nexport const FormatAnnotationId = Symbol.for('@dxos/schema/annotation/Format');\n\nexport const FormatAnnotation = createAnnotationHelper<TypeFormat>(FormatAnnotationId);\n\n/** @deprecated */\nexport const getFormatAnnotation = (node: SchemaAST.AST): TypeFormat | undefined =>\n  Function.pipe(SchemaAST.getAnnotation<TypeFormat>(FormatAnnotationId)(node), Option.getOrUndefined);\n\n// TODO(burdon): Rename Format; Change to discriminated union?\nexport enum TypeFormat {\n  None = 'none',\n\n  //\n  // Scalar\n  //\n\n  String = 'string',\n  Number = 'number',\n  Boolean = 'boolean',\n  Ref = 'ref',\n\n  //\n  // { type: 'string' }\n  //\n\n  DID = 'did', // Users, etc.\n  DXN = 'dxn',\n  Email = 'email',\n  Formula = 'formula', // Spreadsheet formula.\n  Hostname = 'hostname',\n  JSON = 'json',\n  Markdown = 'markdown',\n  Regex = 'regex',\n  SingleSelect = 'single-select',\n  Text = 'text',\n  MultiSelect = 'multi-select',\n  URL = 'url',\n  UUID = 'uuid',\n\n  //\n  // { type: 'number' }\n  //\n\n  Currency = 'currency',\n  Integer = 'integer',\n  Percent = 'percent',\n  Timestamp = 'timestamp',\n\n  //\n  // { type: 'date' }\n  //\n\n  DateTime = 'date-time',\n  Date = 'date',\n  Time = 'time',\n  Duration = 'duration',\n\n  //\n  // { type: 'object' }\n  //\n\n  GeoPoint = 'lnglat',\n}\n\nexport const FormatEnums = Object.values(TypeFormat).sort();\n\nexport const PropertyKind = {\n  type: TypeEnum,\n  format: TypeFormat,\n};\n\n/**\n * Default formats\n */\nexport const typeToFormat: Partial<Record<TypeEnum, TypeFormat>> = {\n  [TypeEnum.String]: TypeFormat.String,\n  [TypeEnum.Number]: TypeFormat.Number,\n  [TypeEnum.Boolean]: TypeFormat.Boolean,\n};\n\n/**\n * Map of format to type.\n */\nexport const formatToType: Record<TypeFormat, TypeEnum> = {\n  [TypeFormat.None]: TypeEnum.String,\n  [TypeFormat.String]: TypeEnum.String,\n  [TypeFormat.Number]: TypeEnum.Number,\n  [TypeFormat.Boolean]: TypeEnum.Boolean,\n  [TypeFormat.Ref]: TypeEnum.Ref,\n\n  // Strings\n  [TypeFormat.DID]: TypeEnum.String,\n  [TypeFormat.DXN]: TypeEnum.String,\n  [TypeFormat.Email]: TypeEnum.String,\n  [TypeFormat.Formula]: TypeEnum.String,\n  [TypeFormat.Hostname]: TypeEnum.String,\n  [TypeFormat.JSON]: TypeEnum.String,\n  [TypeFormat.Markdown]: TypeEnum.String,\n  [TypeFormat.Regex]: TypeEnum.String,\n  [TypeFormat.URL]: TypeEnum.String,\n  [TypeFormat.UUID]: TypeEnum.String,\n  [TypeFormat.SingleSelect]: TypeEnum.String,\n  [TypeFormat.Text]: TypeEnum.String,\n  [TypeFormat.MultiSelect]: TypeEnum.Object,\n\n  // Dates\n  [TypeFormat.Date]: TypeEnum.String,\n  [TypeFormat.DateTime]: TypeEnum.String,\n  [TypeFormat.Duration]: TypeEnum.String,\n  [TypeFormat.Time]: TypeEnum.String,\n\n  // Numbers\n  [TypeFormat.Currency]: TypeEnum.Number,\n  [TypeFormat.Integer]: TypeEnum.Number,\n  [TypeFormat.Percent]: TypeEnum.Number,\n  [TypeFormat.Timestamp]: TypeEnum.Number,\n\n  // Objects\n  [TypeFormat.GeoPoint]: TypeEnum.Array,\n};\n\n/**\n * Allowed value options for select.\n */\nexport const OptionsAnnotationId = Symbol.for('@dxos/schema/annotation/Options');\n\n// TODO(wittjosiah): Reconcile with `SelectOption`.\nexport type Options = string | number;\nexport const OptionsAnnotation = createAnnotationHelper<Options[]>(OptionsAnnotationId);\n\n/** @deprecated */\nexport const getOptionsAnnotation = (node: SchemaAST.AST): Options[] | undefined =>\n  Function.pipe(SchemaAST.getAnnotation<Options[]>(OptionsAnnotationId)(node), Option.getOrUndefined);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\nconst encodeMultipleOf = (divisor: number) => 1 / Math.pow(10, divisor);\n\nconst encodeMultiple =\n  <A extends number>(divisor?: number) =>\n  <I, R>(self: Schema.Schema<A, I, R>) =>\n    divisor === undefined || divisor === 0 ? self : self.pipe(Schema.multipleOf(encodeMultipleOf(divisor)));\n\n/**\n * Convert number of digits to multipleOf annotation.\n */\nexport const DecimalPrecision = Schema.transform(Schema.Number, Schema.Number, {\n  strict: true,\n  encode: (value) => encodeMultipleOf(value),\n  decode: (value) => Math.log10(1 / value),\n}).annotations({\n  title: 'Number of digits',\n});\n\nexport const CurrencyAnnotationId = Symbol.for('@dxos/schema/annotation/Currency');\n\nexport type CurrencyAnnotation = {\n  decimals?: number;\n  code?: string;\n};\n\n/**\n * ISO 4217 currency code.\n */\nexport const Currency = ({ decimals, code }: CurrencyAnnotation = { decimals: 2 }) =>\n  Schema.Number.pipe(\n    encodeMultiple(decimals),\n    FormatAnnotation.set(TypeFormat.Currency),\n    Schema.annotations({\n      title: 'Currency',\n      description: 'Currency value',\n      ...(code ? { [CurrencyAnnotationId]: code.toUpperCase() } : {}),\n    }),\n  );\n\nexport type PercentAnnotation = {\n  decimals?: number;\n};\n\n/**\n * Integer.\n */\nexport const Integer = () =>\n  Schema.Number.pipe(\n    Schema.int(),\n    FormatAnnotation.set(TypeFormat.Integer),\n    Schema.annotations({\n      title: 'Integer',\n      description: 'Integer value',\n    }),\n  );\n\n/**\n * Percent.\n */\n// TODO(burdon): Define min/max (e.g., 0, 1).\nexport const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>\n  Schema.Number.pipe(\n    encodeMultiple(decimals),\n    FormatAnnotation.set(TypeFormat.Percent),\n    Schema.annotations({\n      title: 'Percent',\n      description: 'Percentage value',\n    }),\n  );\n\n/**\n * Unix timestamp.\n * https://en.wikipedia.org/wiki/Unix_time\n */\nexport const Timestamp = Schema.Number.pipe(\n  FormatAnnotation.set(TypeFormat.Timestamp),\n  Schema.annotations({\n    title: 'Timestamp',\n    description: 'Unix timestamp',\n  }),\n);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { clamp } from '@dxos/util';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * GeoJSON Format\n * https://datatracker.ietf.org/doc/html/rfc7946\n * https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.1\n * https://en.wikipedia.org/wiki/Geographic_coordinate_system\n * https://geojson.org\n * {\n *   \"type\": \"Point\",\n *   \"coordinates\": [0, 51.47] // [longitude, latitude]\n * }\n * Note: optional third element for altitude.\n */\nexport const GeoPoint = Schema.Tuple(\n  Schema.Number.pipe(Schema.annotations({ title: 'Longitude' }), Schema.clamp(-180, 180), Schema.multipleOf(0.000001)),\n  Schema.Number.pipe(Schema.annotations({ title: 'Latitude' }), Schema.clamp(-90, 90), Schema.multipleOf(0.000001)),\n  Schema.optionalElement(Schema.Number).annotations({\n    title: 'Height ASL (m)',\n  }),\n).pipe(\n  FormatAnnotation.set(TypeFormat.GeoPoint),\n  Schema.annotations({\n    title: 'GeoPoint',\n    description: 'GeoJSON Position',\n  }),\n);\n\nexport type GeoPoint = Schema.Schema.Type<typeof GeoPoint>;\n\nexport type GeoLocation = {\n  longitude: number;\n  latitude: number;\n  height?: number;\n};\n\n/**\n * Geolocation utilities for working with GeoPoint format.\n */\nexport namespace GeoLocation {\n  /**\n   * Convert latitude and longitude to GeoPoint (GeoJSON format [longitude, latitude, height?]).\n   * Clamps values to valid ranges: latitude [-90, 90], longitude [-180, 180].\n   */\n  export const toGeoPoint = ({ longitude, latitude, height }: GeoLocation): GeoPoint => {\n    // TODO(ZaymonFC): Use schema validation instead of doing this manually.\n    const clampedLongitude = clamp(longitude, -180, 180);\n    const clampedLatitude = clamp(latitude, -90, 90);\n    return height !== undefined ? [clampedLongitude, clampedLatitude, height] : [clampedLongitude, clampedLatitude];\n  };\n\n  /**\n   * Extract latitude and longitude from GeoPoint (GeoJSON format [longitude, latitude, height?]).\n   */\n  export const fromGeoPoint = (geoPoint: GeoPoint | undefined): GeoLocation => {\n    if (!geoPoint) {\n      return { longitude: 0, latitude: 0 };\n    }\n\n    const result: GeoLocation = {\n      longitude: geoPoint[0],\n      latitude: geoPoint[1],\n    };\n\n    // Add height if defined.\n    if (geoPoint[2] !== undefined) {\n      result.height = geoPoint[2];\n    }\n\n    return result;\n  };\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * Email address (RFC 5321)\n * https://datatracker.ietf.org/doc/html/rfc5321#section-4.1.2\n */\nexport const Email = Schema.String.pipe(\n  Schema.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/),\n  FormatAnnotation.set(TypeFormat.Email),\n  Schema.annotations({\n    title: 'Email',\n    description: 'Email address',\n  }),\n);\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formula));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));\n\n/**\n *\n */\n// TODO(burdon): Implement.\nexport const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));\n\n/**\n * Regex\n * https://json-schema.org/understanding-json-schema/reference/regular_expressions\n * https://ecma-international.org/publications-and-standards/standards/ecma-262\n */\n// TODO(burdon): Implement.\nexport const Regex = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex));\n\n/**\n * Multi-line text.\n */\nexport const Text = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Text));\n\n/**\n * https://datatracker.ietf.org/doc/html/rfc3986#section-1.1.3\n */\nexport const URL = Schema.String.pipe(\n  Schema.pattern(/^(\\w+?:\\/\\/)?([\\da-z.-]+)\\.([a-z.]{2,6})([/\\w .-]*)*\\/?$/i),\n  FormatAnnotation.set(TypeFormat.URL),\n  Schema.annotations({\n    title: 'URL',\n    description: 'URL',\n  }),\n);\n\n/**\n * UUID (RFC 4122)\n * https://datatracker.ietf.org/doc/html/rfc4122\n */\nexport const UUID = Schema.UUID.pipe(\n  FormatAnnotation.set(TypeFormat.UUID),\n  Schema.annotations({\n    [SchemaAST.ExamplesAnnotationId]: ['3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a'],\n  }),\n);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport * as Keys from '@dxos/keys';\n\nimport * as DateUtil from './date';\nimport * as NumberUtil from './number';\nimport * as ObjectUtil from './object';\nimport * as StringUtil from './string';\nimport { TypeFormat as TypeFormat$ } from './types';\n\n// TODO(burdon): Media encoding.\n// - https://json-schema.org/understanding-json-schema/reference/non_json_data\n\n/**\n * Formats.\n * https://json-schema.org/understanding-json-schema/reference/string#built-in-formats\n * NOTE: A JSON Schema validator will ignore any format type that it does not understand.\n */\n// TODO(burdon): Add fields for `examples`, `message`, etc.\nexport namespace Format {\n  export import TypeFormat = TypeFormat$;\n\n  // String\n  export const DXN = Keys.DXN.Schema;\n  export const Email = StringUtil.Email;\n  export const Formula = StringUtil.Formula;\n  export const Hostname = StringUtil.Hostname;\n  export const JSON = StringUtil.JSON;\n  export const Markdown = StringUtil.Markdown;\n  export const Regex = StringUtil.Regex;\n  export const URL = StringUtil.URL;\n  export const UUID = Schema.UUID;\n\n  // Numbers\n  // TODO(burdon): BigInt.\n  export const Currency = NumberUtil.Currency;\n  export const Integer = NumberUtil.Integer;\n  export const Percent = NumberUtil.Percent;\n  export const Timestamp = NumberUtil.Timestamp;\n\n  // Dates and times\n  export const Date = DateUtil.DateOnly;\n  export const DateTime = DateUtil.DateTime;\n  export const Duration = DateUtil.Duration;\n  export const Time = DateUtil.TimeOnly;\n\n  // Objects\n  export const GeoPoint = ObjectUtil.GeoPoint;\n  export type GeoPoint = ObjectUtil.GeoPoint; // TODO(burdon): Export types.\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { FormatAnnotation, TypeFormat } from './types';\n\n/**\n * Datetime values should be stored as ISO strings or unix numbers (ms) in UTC.\n *\n * NOTE: HyperFormula uses Excel's time format (null date 1900/01/01)\n * It can be configured to use a different parser via `parseDateTime`.\n * https://hyperformula.handsontable.com/guide/date-and-time-handling.html#date-and-time-handling\n * https://github.com/handsontable/hyperformula/blob/master/src/DateTimeHelper.ts\n */\n\n// TODO(burdon): Annotations not present in JSON.\n// TODO(burdon): Timezone.\n// TODO(burdon): Format for timestamp (Unix UTC or ISO 8601)?\n// TODO(burdon): Refs\n//  - https://www.npmjs.com/package/numfmt\n//  - https://date-fns.org/docs/Getting-Started\n//  - https://github.com/date-fns/tz\n\n/**\n * Simple date compatible with HF.\n */\nexport const SimpleDate = Schema.Struct({\n  year: Schema.Number.pipe(Schema.between(1900, 9999)),\n  month: Schema.Number.pipe(Schema.between(1, 12)),\n  day: Schema.Number.pipe(Schema.between(1, 31)),\n});\n\nexport type SimpleDate = Schema.Schema.Type<typeof SimpleDate>;\n\nexport const toSimpleDate = (date: Date): SimpleDate => ({\n  year: date.getUTCFullYear(),\n  month: date.getUTCMonth() + 1,\n  day: date.getUTCDate(),\n});\n\n/**\n * Simple time compatible with HF.\n */\nexport const SimpleTime = Schema.Struct({\n  hours: Schema.Number.pipe(Schema.between(0, 23)),\n  minutes: Schema.Number.pipe(Schema.between(0, 59)),\n  seconds: Schema.Number.pipe(Schema.between(0, 59)),\n});\n\nexport type SimpleTime = Schema.Schema.Type<typeof SimpleTime>;\n\nexport const toSimpleTime = (date: Date): SimpleTime => ({\n  hours: date.getUTCHours(),\n  minutes: date.getUTCSeconds(),\n  seconds: date.getUTCSeconds(),\n});\n\n/**\n * Simple date-time compatible with HF.\n */\nexport const SimpleDateTime = Schema.extend(SimpleDate, SimpleTime);\n\nexport type SimpleDateTime = Schema.Schema.Type<typeof SimpleDateTime>;\n\nexport const toSimpleDateTime = (date: Date): SimpleDateTime => ({\n  ...toSimpleDate(date),\n  ...toSimpleTime(date),\n});\n\n/**\n * https://effect.website/docs/guides/schema/transformations#date-transformations\n */\n\n// TODO(burdon): Consider if transformations should be supported with Automerge.\n\n/**\n * Format: 2018-11-13\n */\nexport const DateOnly = /* Schema.transformOrFail(Schema.String, SimpleDate, {\n  strict: true,\n  decode: (str, _, ast) => {\n    if (!isValidDateFormat(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected YYYY-MM-DD format'));\n    }\n    if (!isValidDate(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Invalid date'));\n    }\n\n    const [year, month, day] = str.split('-').map(Number);\n    return ParseResult.succeed({ year, month, day });\n  },\n  encode: (date) => {\n    return ParseResult.succeed(\n      [\n        date.year.toString().padStart(4, '0'),\n        date.month.toString().padStart(2, '0'),\n        date.day.toString().padStart(2, '0'),\n      ].join('-'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Date),\n  Schema.annotations({\n    title: 'Date',\n    description: 'Valid date in ISO format',\n  }),\n);\n\n/**\n * Format: 20:20:39+00:00\n */\nexport const TimeOnly = /* Schema.transformOrFail(Schema.String, SimpleTime, {\n  strict: true,\n  decode: (str, _, ast) => {\n    if (!isValidTimeFormat(str)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));\n    }\n\n    const [hours, minutes, seconds] = str.split(':').map(Number);\n    return ParseResult.succeed({ hours, minutes, seconds });\n  },\n  encode: (time) => {\n    return ParseResult.succeed(\n      [\n        time.hours.toString().padStart(2, '0'),\n        time.minutes.toString().padStart(2, '0'),\n        time.seconds.toString().padStart(2, '0'),\n      ].join(':'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Time),\n  Schema.annotations({\n    title: 'Time',\n    description: 'Valid time in ISO format',\n  }),\n);\n\n/**\n * Format: 2018-11-13T20:20:39+00:00\n */\nexport const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime, {\n  strict: false,\n  decode: (str, _, ast) => {\n    const [date, time] = str.split('T');\n    if (!isValidDateFormat(date)) {\n      return ParseResult.fail(new ParseResult.Type(ast, date, 'Expected YYYY-MM-DD format'));\n    }\n    if (!isValidDate(date)) {\n      return ParseResult.fail(new ParseResult.Type(ast, date, 'Invalid date'));\n    }\n    if (!isValidTimeFormat(time)) {\n      return ParseResult.fail(new ParseResult.Type(ast, str, 'Expected HH:mm:ss format'));\n    }\n\n    const [year, month, day] = date.split('-').map(Number);\n    const [hours, minutes, seconds] = time.split(':').map(Number);\n    return ParseResult.succeed({ year, month, day, hours, minutes, seconds });\n  },\n  encode: (datetime) => {\n    return ParseResult.succeed(\n      [\n        [\n          datetime.year.toString().padStart(4, '0'),\n          datetime.month.toString().padStart(2, '0'),\n          datetime.day.toString().padStart(2, '0'),\n        ].join('-'),\n        [\n          datetime.hours.toString().padStart(2, '0'),\n          datetime.minutes.toString().padStart(2, '0'),\n          datetime.seconds.toString().padStart(2, '0'),\n        ].join(':'),\n      ].join('T'),\n    );\n  },\n}) */ Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.DateTime),\n  Schema.annotations({\n    title: 'DateTime',\n    description: 'Valid date and time in ISO format',\n  }),\n);\n\n/**\n * https://datatracker.ietf.org/doc/html/rfc3339#appendix-A\n */\n// TODO(burdon): Define duration type.\nexport const Duration = Schema.String.pipe(\n  FormatAnnotation.set(TypeFormat.Duration),\n  Schema.annotations({\n    title: 'Duration',\n    description: 'Duration in ISO 8601 format',\n    [SchemaAST.ExamplesAnnotationId]: ['1h', '3D'],\n  }),\n);\n\n//\n// Utils\n//\n\n// YYYY-MM-DD\nconst DATE_REGEX = /^\\d{4}-\\d{2}-\\d{2}$/;\n\nconst _isValidDateFormat = (str: string) => DATE_REGEX.test(str);\n\nconst _isValidDate = (str: string) => {\n  const date = new Date(str);\n  return !isNaN(date.getTime()) && date.toISOString().startsWith(str);\n};\n\n// HH:mm:ss\nconst TIME_REGEX = /^([01]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)$/;\n\nconst _isValidTimeFormat = (str: string) => TIME_REGEX.test(str);\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n/**\n * Schema for a single select option. Used to define choices in a {single|multi}-select field.\n */\nexport const SelectOption = Schema.Struct({\n  /** Stable identifier for the option. */\n  id: Schema.NonEmptyString,\n  title: Schema.String,\n  /** Color palette used for visual styling. */\n  color: Schema.String,\n});\n\nexport type SelectOption = Schema.Schema.Type<typeof SelectOption>;\n"],
-  "mappings": "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",
-  "names": ["Function", "Option", "SchemaAST", "TypeEnum", "getTypeEnum", "property", "type", "undefined", "FormatAnnotationId", "Symbol", "for", "FormatAnnotation", "createAnnotationHelper", "getFormatAnnotation", "node", "pipe", "getAnnotation", "getOrUndefined", "TypeFormat", "FormatEnums", "Object", "values", "sort", "PropertyKind", "format", "typeToFormat", "formatToType", "OptionsAnnotationId", "OptionsAnnotation", "getOptionsAnnotation", "Schema", "encodeMultipleOf", "divisor", "Math", "pow", "encodeMultiple", "self", "undefined", "pipe", "multipleOf", "DecimalPrecision", "transform", "Number", "strict", "encode", "value", "decode", "log10", "annotations", "title", "CurrencyAnnotationId", "Symbol", "for", "Currency", "decimals", "code", "FormatAnnotation", "set", "TypeFormat", "description", "toUpperCase", "Integer", "int", "Percent", "Timestamp", "Schema", "clamp", "GeoPoint", "Tuple", "Number", "pipe", "annotations", "title", "clamp", "multipleOf", "optionalElement", "FormatAnnotation", "set", "TypeFormat", "description", "GeoLocation", "toGeoPoint", "longitude", "latitude", "height", "clampedLongitude", "clampedLatitude", "undefined", "fromGeoPoint", "geoPoint", "result", "Schema", "SchemaAST", "Email", "String", "pipe", "pattern", "FormatAnnotation", "set", "TypeFormat", "annotations", "title", "description", "Formula", "Hostname", "JSON", "Markdown", "Regex", "Text", "URL", "UUID", "ExamplesAnnotationId", "Schema", "Keys", "Schema", "SchemaAST", "SimpleDate", "Struct", "year", "Number", "pipe", "between", "month", "day", "SimpleTime", "Struct", "hours", "Number", "pipe", "between", "minutes", "seconds", "SimpleDateTime", "extend", "SimpleDate", "SimpleTime", "DateOnly", "String", "pipe", "FormatAnnotation", "set", "TypeFormat", "Date", "annotations", "title", "description", "TimeOnly", "Time", "DateTime", "Duration", "ExamplesAnnotationId", "Format", "TypeFormat", "DXN", "Schema", "Email", "Formula", "Hostname", "JSON", "Markdown", "Regex", "URL", "UUID", "Currency", "Integer", "Percent", "Timestamp", "Date", "DateOnly", "DateTime", "Duration", "Time", "TimeOnly", "GeoPoint", "Schema", "SelectOption", "Struct", "id", "NonEmptyString", "title", "String", "color"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Err.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { BaseError, type BaseErrorOptions } from '@dxos/errors';\nimport { type DXN } from '@dxos/keys';\n\nexport class SchemaNotFoundError extends BaseError.extend('SchemaNotFoundError', 'Schema not found') {\n  constructor(schema: string, options?: BaseErrorOptions) {\n    super({ context: { schema }, ...options });\n  }\n}\n\nexport class ObjectNotFoundError extends BaseError.extend('ObjectNotFoundError', 'Object not found') {\n  constructor(dxn: DXN, options?: BaseErrorOptions) {\n    super({ context: { dxn }, ...options });\n  }\n}\n\n/**\n * Reason why getting a reactive object from a snapshot failed.\n * - `no-database`: The snapshot is not associated with a database.\n * - `object-not-found`: The object was removed or does not exist in the database.\n */\nexport type GetReactiveErrorReason = 'no-database' | 'object-not-found';\n\n/**\n * Error thrown when a reactive object cannot be resolved from a snapshot.\n * Extends `BaseError` with a `reason` and optional `snapshotId` in its context.\n */\nexport class GetReactiveError extends BaseError.extend(\n  'GetReactiveError',\n  'Failed to get reactive object from snapshot',\n) {\n  constructor(options: { reason: GetReactiveErrorReason; snapshotId?: string } & BaseErrorOptions) {\n    super({ context: { reason: options.reason, snapshotId: options.snapshotId }, ...options });\n  }\n}\n"],
-  "mappings": ";;;;;AAAA;;;;;;AAIA,SAASA,iBAAwC;AAG1C,IAAMC,sBAAN,cAAkCC,UAAUC,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYC,QAAgBC,SAA4B;AACtD,UAAM;MAAEC,SAAS;QAAEF;MAAO;MAAG,GAAGC;IAAQ,CAAA;EAC1C;AACF;AAEO,IAAME,sBAAN,cAAkCL,UAAUC,OAAO,uBAAuB,kBAAA,EAAA;EAC/E,YAAYK,KAAUH,SAA4B;AAChD,UAAM;MAAEC,SAAS;QAAEE;MAAI;MAAG,GAAGH;IAAQ,CAAA;EACvC;AACF;AAaO,IAAMI,mBAAN,cAA+BP,UAAUC,OAC9C,oBACA,6CAAA,EAAA;EAEA,YAAYE,SAAqF;AAC/F,UAAM;MAAEC,SAAS;QAAEI,QAAQL,QAAQK;QAAQC,YAAYN,QAAQM;MAAW;MAAG,GAAGN;IAAQ,CAAA;EAC1F;AACF;",
-  "names": ["BaseError", "SchemaNotFoundError", "BaseError", "extend", "schema", "options", "context", "ObjectNotFoundError", "dxn", "GetReactiveError", "reason", "snapshotId"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/JsonSchema.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as internal from './internal';\n\n/**\n * Decode JSON Schema to Effect Schema.\n */\nexport const toEffectSchema = internal.toEffectSchema;\n\n/**\n * Encode Effect Schema to JSON Schema.\n */\nexport const toJsonSchema = internal.toJsonSchema;\n\n/**\n * Serializable JsonSchema type definition.\n */\nexport type JsonSchema = internal.JsonSchemaType;\n\nexport const JsonSchema: Schema.Schema<internal.JsonSchemaType> = internal.JsonSchemaType;\n"],
-  "mappings": ";;;;;;;;;;AAAA;;;wBAAAA;EAAA,oBAAAC;;AAWO,IAAMC,kBAA0BA;AAKhC,IAAMC,gBAAwBA;AAO9B,IAAMC,aAA8DC;",
-  "names": ["toEffectSchema", "toJsonSchema", "toEffectSchema", "toJsonSchema", "JsonSchema", "JsonSchemaType"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Annotation.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nexport {\n  DescriptionAnnotation,\n  FormInputAnnotation,\n  GeneratorAnnotation,\n  LabelAnnotation,\n  ReferenceAnnotation,\n  SystemTypeAnnotation,\n  TypeAnnotation,\n  getDescriptionWithSchema,\n  getLabelWithSchema,\n  getTypeAnnotation,\n  setDescriptionWithSchema,\n  setLabelWithSchema,\n  IconAnnotation,\n} from './internal/annotations';\n\nimport type * as Schema from 'effect/Schema';\n\nimport * as internalAnnotations from './internal/annotations';\n\ninterface MakeProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n/**\n * Create a new schema annotation.\n * Annotation can be assigned both to fields and to the schema itself.\n * Annotation is serialized with the schema.\n *\n * @example\n * ```ts\n * const ColorAnnotation = Annotation.make({\n *   id: 'dxos.org/annotation/Color',\n *   schema: Schema.String,\n * });\n *\n * const schema = Schema.String.annotations(ColorAnnotation.set('red'));\n * ```\n */\nexport const make: <T>(props: MakeProps<T>) => internalAnnotations.AnnotationHelper<T> =\n  internalAnnotations.makeUserAnnotation;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;AA4CO,IAAMA,OACSC;",
-  "names": ["make", "makeUserAnnotation"]
-}