@dxos/echo 0.8.4-main.9be5663bfe → 0.8.4-main.abd8ff62ef

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

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

package/dist/lib/neutral/chunk-6URFBQJH.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/internal/common/types/typename.ts", "../../../src/internal/Annotation/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 Mutable } from '../common/proxy';\nimport { type AnyProperties, EntityKind, TypeId, getSchema } from '../common/types';\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: `org.dxos.type.message`\n */\n// TODO(wittjosiah): Factor out to DXN spec.\n// TODO(wittjosiah): Switch to atproto NSID regex once legacy typenames are fully migrated:\n//   /^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)$/\nexport const TypenameSchema = Schema.String.pipe(\n  Schema.pattern(/^[a-zA-Z][a-zA-Z0-9]*(\\.[a-zA-Z][a-zA-Z0-9-]*){2,}$/),\n).annotations({\n  description: 'Fully qualified globally unique typename in reverse-DNS form.',\n  example: 'org.dxos.type.message',\n});\n\n/**\n * Semantic version format: `major.minor.patch`\n * Example: `1.0.0`\n */\nexport const VersionSchema = Schema.String.pipe(Schema.pattern(/^\\d+.\\d+.\\d+$/)).annotations({\n  description: 'Semantic version format: `major.minor.patch`',\n  example: '1.0.0',\n});\n\nexport const TypeMeta = Schema.Struct({\n  typename: TypenameSchema,\n  version: VersionSchema,\n});\n\nexport interface TypeMeta extends Schema.Schema.Type<typeof TypeMeta> {}\n\n/**\n * Entity type.\n */\nexport const TypeAnnotationId = Symbol.for('@dxos/schema/annotation/Type');\n\n/**\n * Payload stored under {@link TypeAnnotationId}.\n */\nexport const TypeAnnotation = Schema.extend(\n  TypeMeta,\n  Schema.Struct({\n    kind: Schema.Enums(EntityKind),\n\n    /**\n     * If this is a relation, the schema of the source object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    sourceSchema: Schema.optional(DXN.Schema),\n\n    /**\n     * If this is a relation, the schema of the target object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    targetSchema: Schema.optional(DXN.Schema),\n  }),\n);\n\nexport interface TypeAnnotation extends Schema.Schema.Type<typeof TypeAnnotation> {}\n\n/**\n * @returns {@link TypeAnnotation} from a schema.\n * Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.\n */\nexport const getTypeAnnotation = (schema: Schema.Schema.All): TypeAnnotation | undefined => {\n  assertArgument(schema != null && schema.ast != null, 'schema', 'invalid schema');\n  return Function.flow(\n    SchemaAST.getAnnotation<TypeAnnotation>(TypeAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n};\n\n/**\n * @returns {@link EntityKind} from a schema.\n */\nexport const getEntityKind = (schema: Schema.Schema.All): EntityKind | undefined => getTypeAnnotation(schema)?.kind;\n\n/**\n * @internal\n * @returns Schema typename (without dxn: prefix or version number).\n */\nexport const getSchemaTypename = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.typename;\n\n/**\n * @internal\n * @returns Schema version in semver format.\n */\nexport const getSchemaVersion = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.version;\n\n/**\n * Gets the typename of the object without the version.\n * Returns only the name portion, not the DXN.\n * @example \"org.example.type.contact\"\n *\n * @internal (use Obj.getTypename)\n */\nexport const getTypename = (obj: AnyProperties): string | undefined => {\n  const schema = getSchema(obj);\n  if (schema != null) {\n    // Try to extract typename from DXN.\n    return getSchemaTypename(schema);\n  } else {\n    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:com.example.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 * Skips empty strings and whitespace-only strings, continuing to the next field.\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        const trimmed = value.trim();\n        if (trimmed.length > 0) {\n          return value;\n        }\n        continue;\n      }\n      case 'number':\n      case 'boolean':\n      case 'bigint':\n      case 'symbol':\n        return value.toString();\n      case 'undefined':\n      case 'object':\n      case 'function':\n        continue;\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Sets the label for a given object based on {@link LabelAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\nexport const setLabelWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n  label: string,\n) => {\n  const annotation = LabelAnnotation.get(schema).pipe(\n    Option.map((field) => field[0]),\n    Option.getOrElse(() => 'name'),\n  );\n  object[annotation] = label;\n};\n\n/**\n * Identifies description property or JSON path expression.\n * A string representing field accessor.\n */\nexport const DescriptionAnnotationId = Symbol.for('@dxos/schema/annotation/Description');\nexport const DescriptionAnnotation = createAnnotationHelper<string>(DescriptionAnnotationId);\n\n/**\n * Returns the description for a given object based on {@link DescriptionAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\n// TODO(burdon): Convert to 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-z][a-z0-9]*(\\.[a-z][a-z0-9-]*){2,}$/.test(props.id),\n    'id',\n    'Annotation id must be in the FQN format (org.dxos.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: 'org.dxos.annotation.icon',\n  schema: IconAnnotationSchema,\n});\n\n/**\n * Get the label of an entity.\n * Accepts both reactive entities and snapshots.\n */\nexport const getLabel = (entity: AnyProperties): string | undefined => {\n  const schema = getSchema(entity);\n  if (schema != null) {\n    return getLabelWithSchema(schema, entity);\n  }\n};\n\n/**\n * Set the label of an entity.\n * Must be called within an Obj.change or Relation.change callback.\n */\nexport const setLabel = (entity: Mutable<AnyProperties>, label: string) => {\n  const schema = getSchema(entity);\n  if (schema != null) {\n    setLabelWithSchema(schema, entity, label);\n  }\n};\n\n/**\n * Get the description of an entity.\n * Accepts both reactive entities and snapshots.\n */\nexport const getDescription = (entity: AnyProperties): string | undefined => {\n  const schema = getSchema(entity);\n  if (schema != null) {\n    return getDescriptionWithSchema(schema, entity);\n  }\n};\n\n/**\n * Set the description of an entity.\n * Must be called within an Obj.change or Relation.change callback.\n */\nexport const setDescription = (entity: Mutable<AnyProperties>, description: string) => {\n  const schema = getSchema(entity);\n  if (schema != null) {\n    setDescriptionWithSchema(schema, entity, description);\n  }\n};\n"],
-  "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", "trimmed", "trim", "length", "toString", "setLabelWithSchema", "label", "field", "DescriptionAnnotationId", "DescriptionAnnotation", "getDescriptionWithSchema", "setDescriptionWithSchema", "FormInputAnnotationId", "FormInputAnnotation", "FieldLookupAnnotationId", "GeneratorAnnotationId", "GeneratorAnnotation", "makeUserAnnotation", "props", "test", "getFromAst", "decodeUnknownSync", "set", "encodeSync", "IconAnnotationSchema", "icon", "hue", "IconAnnotation", "getLabel", "entity", "setLabel", "getDescription", "setDescription"]
-}

package/dist/lib/neutral/chunk-7SQD3FRZ.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';\nexport * as Extension from './Extension';\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 * Manages cross-space database interactions.\n */\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   * Get a database by space ID.\n   * @returns The database for the given space ID, or undefined if not found.\n   */\n  getDatabase(spaceId: Key.SpaceId): Database.Database | undefined;\n}\n", "//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Schema from 'effect/Schema';\n\nimport * as Annotation from './Annotation';\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: 'org.dxos.type.collection',\n    version: '0.1.0',\n  }),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--folder--regular',\n    hue: 'neutral',\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\n// @import-as-namespace\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 Annotation from './Annotation';\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: 'org.dxos.type.view',\n    version: '0.1.0',\n  }),\n  internal.SystemTypeAnnotation.set(true),\n  Annotation.IconAnnotation.set({\n    icon: 'ph--funnel--regular',\n    hue: 'green',\n  }),\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\n// @import-as-namespace\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;;AAMA,YAAYC,YAAY;AAWjB,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,GACWC,eAAeJ,IAAI;EAC5BK,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAKK,IAAMC,QAAO,CAACC,QAAmD,CAAC,MACnED,KAAKlB,YAAY;EAAEM,SAAS,CAAA;EAAI,GAAGa;AAAM,CAAA;AAExC,IAAMC,eAA4DC,WAAWrB,UAAAA;;;ACpCpF;;;;;;;cAAAsB;;AAMA,YAAYC,aAAY;AAExB,SAASC,gBAAgB;AACzB,SAASC,gBAAgB;AACzB,SAASC,iBAAiB;AAYnB,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,GACvBC,eAAeD,IAAI;EAC5BE,MAAM;EACNC,KAAK;AACP,CAAA,CAAA;AAaK,IAAMC,OAAuBf;AAE7B,IAAMgB,QAAO,CAACC,UAAAA;AACnB,SAAWD,KAAKD,MAAM;IACpBd,OAAO;MAAEE,KAAWe,OAAcC,QAAO,CAAA,EAAIhB;IAAI;IACjDG,YAAY;MAAET,QAAQ,CAAA;IAAG;IACzB,GAAGoB;EACL,CAAA;AACF;;;AC1GA;;;;;AAMA,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", "IconAnnotation", "icon", "hue", "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", "IconAnnotation", "icon", "hue", "View", "make", "props", "select", "nothing", "pipe", "Predicate", "Schema", "Dataset", "Union", "Feed", "Collection", "View", "isDataset", "pipe", "instanceOf", "or"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Database.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, type SpaceId } from '@dxos/keys';\n\nimport type * as Entity from './Entity';\nimport * as Err from './Err';\nimport type * as Filter from './Filter';\nimport type * as Hypergraph from './Hypergraph';\nimport { isInstanceOf } from './internal/Annotation';\nimport { type AnyProperties } from './internal/common/types';\nimport type { Ref } from './internal/Ref/ref';\nimport type * as Obj from './Obj';\nimport type * as Query from './Query';\nimport type * as QueryResult from './QueryResult';\nimport type * as SchemaRegistry from './SchemaRegistry';\nimport type * as Type from './Type';\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\nexport interface QueryFn {\n  <Q extends Query.Any>(query: Q): QueryResult.QueryResult<Query.Type<Q>>;\n  <F extends Filter.Any>(filter: F): QueryResult.QueryResult<Filter.Type<F>>;\n}\n\n/**\n * Common interface for Database and Queue.\n */\nexport interface Queryable {\n  query: QueryFn;\n}\n\nexport type GetObjectByIdOptions = {\n  deleted?: boolean;\n};\n\nexport type ObjectPlacement = 'root-doc' | 'linked-doc';\n\nexport type AddOptions = {\n  /**\n   * Where to place the object in the Automerge document tree.\n   * Root document is always loaded with the space.\n   * Linked documents are loaded lazily.\n   * Placing large number of objects in the root document may slow down the initial load.\n   *\n   * @default 'linked-doc'\n   */\n  placeIn?: ObjectPlacement;\n};\n\nexport type FlushOptions = {\n  /**\n   * Write any pending changes to disk.\n   * @default true\n   */\n  disk?: boolean;\n\n  /**\n   * Wait for pending index updates.\n   * @default true\n   */\n  indexes?: boolean;\n\n  /**\n   * Flush pending updates to objects and queries.\n   * @default false\n   */\n  updates?: boolean;\n};\n\n/**\n * Identifier denoting an ECHO Database.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Database');\nexport type TypeId = typeof TypeId;\n\n/**\n * ECHO Database interface.\n */\nexport interface Database extends Queryable {\n  readonly [TypeId]: TypeId;\n\n  get spaceId(): SpaceId;\n\n  // TODO(burdon): Can we move this into graph?\n  get schemaRegistry(): SchemaRegistry.SchemaRegistry;\n\n  get graph(): Hypergraph.Hypergraph;\n\n  toJSON(): object;\n\n  /**\n   * Return object by local ID.\n   */\n  getObjectById<T extends Obj.Unknown = Obj.OfShape<AnyProperties>>(\n    id: string,\n    opts?: GetObjectByIdOptions,\n  ): T | undefined;\n\n  /**\n   * Query objects.\n   */\n  query: QueryFn;\n\n  /**\n   * Creates a reference to an existing object in the database.\n   *\n   * NOTE: The reference may be dangling if the object is not present in the database.\n   * NOTE: Difference from `Ref.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<T>;\n\n  /**\n   * Adds object to the database.\n   */\n  add<T extends Entity.Unknown = Entity.Unknown>(obj: T, opts?: AddOptions): T;\n\n  /**\n   * Removes object from the database.\n   */\n  // TODO(burdon): Return true if removed (currently throws if not present).\n  remove(obj: Entity.Unknown): void;\n\n  /**\n   * Wait for all pending changes to be saved to disk.\n   * Optionaly waits for changes to be propagated to indexes and event handlers.\n   */\n  flush(opts?: FlushOptions): Promise<void>;\n}\n\nexport const isDatabase = (obj: unknown): obj is Database => {\n  return obj ? typeof obj === 'object' && TypeId in obj && obj[TypeId] === TypeId : false;\n};\n\nexport const Database: Schema.Schema<Database> = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));\n\n/**\n * Effect service tag for Database dependency injection.\n */\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {}\n\n/**\n * Layer that provides a Database service that throws when accessed.\n * Useful as a default layer when no database is available.\n */\nexport const notAvailable = Layer.succeed(Service, {\n  get db(): Database {\n    throw new Error('Database not available');\n  },\n});\n\n/**\n * Creates a Database service instance from a Database.\n */\nexport const makeService = (db: Database): Context.Tag.Service<Service> => {\n  return {\n    get db() {\n      return db;\n    },\n  };\n};\n\n/**\n * Creates a Layer that provides the Database service.\n */\nexport const layer = (db: Database): Layer.Layer<Service> => {\n  return Layer.succeed(Service, makeService(db));\n};\n\n/**\n * Returns the space ID of the database.\n */\nexport const spaceId = Effect.gen(function* () {\n  const { db } = yield* Service;\n  return db.spaceId;\n});\n\n/**\n * Resolves an object by its DXN.\n */\nexport const resolve: {\n  // No type check.\n  (ref: DXN | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n  // Check matches schema.\n  <S extends Type.AnyEntity>(\n    ref: DXN | Ref<any>,\n    schema: S,\n  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n} = (<S extends Type.AnyEntity>(\n  ref: DXN | Ref<any>,\n  schema?: S,\n): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service> =>\n  Effect.gen(function* () {\n    const { db } = yield* Service;\n    const dxn = ref instanceof DXN ? ref : ref.dxn;\n    const object = yield* promiseWithCauseCapture(() =>\n      db.graph\n        .createRefResolver({\n          context: {\n            space: db.spaceId,\n          },\n        })\n        .resolve(dxn),\n    );\n\n    if (!object) {\n      return yield* Effect.fail(new Err.ObjectNotFoundError(dxn));\n    }\n    invariant(!schema || isInstanceOf(schema, object), 'Object type mismatch.');\n    return object as any;\n  })) as any;\n\n/**\n * Loads an object reference.\n */\nexport const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn(function* (ref) {\n  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());\n  if (!object) {\n    return yield* Effect.fail(new Err.ObjectNotFoundError(ref.dxn));\n  }\n  return object;\n});\n\n/**\n * Loads an object reference option.\n */\n// TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.\nexport const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {\n  const object = yield* load(ref).pipe(Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)));\n\n  return Option.fromNullable(object);\n});\n\n/**\n * Adds an object to the database.\n * @see {@link Database.add}\n */\nexport const add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.add(obj)));\n\n/**\n * Removes an object from the database.\n * @see {@link Database.remove}\n */\nexport const remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n  Service.pipe(Effect.map(({ db }) => db.remove(obj)));\n\n/**\n * Flushes pending changes to disk.\n * @see {@link Database.flush}\n */\nexport const flush = (opts?: FlushOptions) =>\n  Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));\n\n/**\n * Creates a `QueryResult` object that can be subscribed to.\n */\nexport const query: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<QueryResult.QueryResult<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<QueryResult.QueryResult<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  Service.pipe(\n    Effect.map(({ db }) => db.query(queryOrFilter as any) as QueryResult.QueryResult<any>),\n    Effect.withSpan('Database.query'),\n  );\n\n/**\n * Executes the query once and returns the results.\n */\nexport const runQuery: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));\n\n/**\n * Executes the query once and returns the first result as or None.\n */\nexport const runQueryFirst: {\n  <Q extends Query.Any>(query: Q): Effect.Effect<Option.Option<Query.Type<Q>>, never, Service>;\n  <F extends Filter.Any>(filter: F): Effect.Effect<Option.Option<Filter.Type<F>>, never, Service>;\n} = (queryOrFilter: Query.Any | Filter.Any) =>\n  query(queryOrFilter as any).pipe(\n    Effect.flatMap((queryResult) =>\n      promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined())),\n    ),\n  );\n\n/**\n * Creates a schema query result that can be subscribed to.\n */\n// TODO(dmaretskyi): Change API to `yield* Database.querySchema(...).first` and `yield* Database.querySchema(...).schema`.\nexport const schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<QueryResult.QueryResult<SchemaRegistry.ExtractQueryResult<Q>>, never, Service> =>\n  Service.pipe(\n    Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)),\n    Effect.withSpan('Database.schemaQuery'),\n  );\n\n/**\n * Executes a schema query once and returns the results.\n */\nexport const runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n  schemaQueryOptions?: Q & SchemaRegistry.Query,\n): Effect.Effect<SchemaRegistry.ExtractQueryResult<Q>[], never, Service> =>\n  schemaQuery(schemaQueryOptions).pipe(\n    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n  );\n"],
-  "mappings": "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",
-  "names": ["Context", "Effect", "Layer", "Option", "Schema", "promiseWithCauseCapture", "invariant", "DXN", "TypeId", "Symbol", "for", "isDatabase", "obj", "Database", "Any", "pipe", "filter", "space", "Service", "Tag", "notAvailable", "succeed", "db", "Error", "makeService", "layer", "spaceId", "gen", "resolve", "ref", "schema", "dxn", "DXN", "object", "promiseWithCauseCapture", "graph", "createRefResolver", "context", "fail", "ObjectNotFoundError", "invariant", "isInstanceOf", "load", "fn", "tryLoad", "loadOption", "catchTag", "undefined", "fromNullable", "add", "map", "remove", "flush", "opts", "flatMap", "query", "queryOrFilter", "withSpan", "runQuery", "queryResult", "run", "runQueryFirst", "firstOrUndefined", "schemaQuery", "schemaQueryOptions", "schemaRegistry", "runSchemaQuery"]
-}