@dxos/echo 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Entity.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport type { DXN, ObjectId } from '@dxos/keys';\n\nimport {\n  type ChangeCallback,\n  EntityKind,\n  EntityKindSchema,\n  KindId,\n  type Mutable,\n  type ObjectJSON,\n  type ObjectMeta,\n  type ReadonlyMeta,\n  SnapshotKindId,\n  addTag as addTag$,\n  change as change$,\n  getDXN as getDXN$,\n  getDatabase as getDatabase$,\n  getDescription as getDescription$,\n  getEntityKind,\n  getKeys as getKeys$,\n  getLabel as getLabel$,\n  getMetaChecked as getMeta$,\n  getTypeDXN as getTypeDXN$,\n  getTypename as getTypename$,\n  isDeleted as isDeleted$,\n  removeTag as removeTag$,\n  subscribe as subscribe$,\n  objectToJSON as toJSON$,\n} from './internal';\n\n// Re-export KindId and SnapshotKindId from internal.\nexport { KindId, SnapshotKindId };\n\n// NOTE: Relation does not extend Obj so that, for example, we can prevent Relations from being used as source and target objects.\n//  However, we generally refer to Obj and Relation instances as \"objects\",\n//  and many API methods accept both Obj.Unknown and Relation.Unknown (i.e., Entity.Unknown) instances.\n\nexport const Kind = EntityKind;\nexport type Kind = EntityKind;\nexport const KindSchema = EntityKindSchema;\n\n/**\n * Assigns a kind to an Object or Relation instance.\n * NOTE: Needed to make `isRelation` and `isObject` checks work.\n */\nexport interface OfKind<K extends Kind> {\n  readonly [KindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Assigns a snapshot kind to an Object or Relation snapshot.\n */\nexport interface SnapshotOfKind<K extends Kind> {\n  readonly [SnapshotKindId]: K;\n  readonly id: ObjectId;\n}\n\n/**\n * Obj or Relation with a specific set of properties.\n */\nexport type Entity<Props> = OfKind<Kind> & Props;\n\n/**\n * Unknown Obj or Relation (reactive).\n */\nexport interface Unknown extends OfKind<Kind> {}\n\n/**\n * Snapshot of an Obj or Relation.\n * Branded with SnapshotKindId instead of KindId.\n */\nexport interface Snapshot extends SnapshotOfKind<Kind> {}\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 * This type is very permissive and allows accessing any property on the object.\n * We should move to Obj.Unknown that is not permissive and requires explicit instanceof checks..\n */\nexport interface Any extends OfKind<Kind> {\n  [key: string]: unknown;\n}\n\nexport const getKind = getEntityKind;\n\n//\n// Entity-level functions that work on any entity (object or relation).\n// Use these when you don't know or care about the specific entity kind.\n// For kind-specific functions, use Obj.* or Relation.*.\n//\n\n/**\n * JSON representation of an entity.\n */\nexport type JSON = ObjectJSON;\n\n/**\n * Get the DXN of an entity (object or relation).\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => getDXN$(entity);\n\n/**\n * Get the DXN of an entity's type.\n */\nexport const getTypeDXN = getTypeDXN$;\n\n/**\n * Get the typename of an entity's type.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => getTypename$(entity);\n\n/**\n * Get the database an entity belongs to.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): any | undefined => getDatabase$(entity);\n\n/**\n * Get the metadata for an entity.\n * Returns mutable meta when passed a mutable entity (inside change callback).\n * Returns read-only meta when passed a regular entity or snapshot.\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>): ObjectMeta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): ObjectMeta | ReadonlyMeta {\n  return getMeta$(entity);\n}\n\n/**\n * Get foreign keys for an entity from the specified source.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => getKeys$(entity, source);\n\n/**\n * Check if an entity is deleted.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => isDeleted$(entity);\n\n/**\n * Get the label of an entity.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => getLabel$(entity);\n\n/**\n * Get the description of an entity.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => getDescription$(entity);\n\n/**\n * Convert an entity to its JSON representation.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => toJSON$(entity);\n\n/**\n * Subscribe to changes on an entity (object or relation).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (entity: Unknown, callback: () => void): (() => void) => {\n  return subscribe$(entity, callback);\n};\n\n//\n// Change\n//\n\n/**\n * Used to provide a mutable view of an entity within `Entity.change`.\n */\nexport type { Mutable };\n\n/**\n * Perform mutations on an entity (object or relation) within a change context.\n *\n * Entities are read-only by default. Mutations are batched and notifications fire\n * when the callback completes. Direct mutations outside of `Entity.change` will throw\n * at runtime.\n *\n * @param entity - The echo entity (object or relation) to mutate.\n * @param callback - Receives a mutable view of the entity. All mutations must occur here.\n *\n * @example\n * ```typescript\n * // Mutate within Entity.change\n * Entity.change(entity, (e) => {\n *   e.name = 'Updated';\n *   e.count = 42;\n * });\n *\n * // Direct mutation throws\n * entity.name = 'Bob'; // Error: Cannot modify outside Entity.change()\n * ```\n *\n * Note: For type-specific operations, prefer `Obj.change` or `Relation.change`.\n */\nexport const change = <T extends Unknown>(entity: T, callback: ChangeCallback<T>): void => {\n  change$(entity, callback);\n};\n\n/**\n * Add a tag to an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => addTag$(entity, tag);\n\n/**\n * Remove a tag from an entity.\n * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => removeTag$(entity, tag);\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;gBAAAA;EAAA,cAAAC;EAAA,cAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,eAAAC;EAAA;kBAAAC;EAAA;oBAAAC;EAAA,mBAAAC;EAAA,iBAAAC;EAAA,iBAAAC;EAAA,iBAAAC;EAAA;;AAyCO,IAAMC,OAAOC;AAEb,IAAMC,aAAaC;AAgDnB,IAAMC,UAAUC;AAgBhB,IAAMC,UAAS,CAACC,WAAoCC,OAAQD,MAAAA;AAK5D,IAAME,cAAaC;AAKnB,IAAMC,eAAc,CAACJ,WAAmDK,YAAaL,MAAAA;AAKrF,IAAMM,eAAc,CAACN,WAAgDO,YAAaP,MAAAA;AAUlF,SAASQ,QAAQR,QAA6C;AACnE,SAAOS,eAAST,MAAAA;AAClB;AAKO,IAAMU,WAAU,CAACV,QAA4BW,WAAiCC,QAASZ,QAAQW,MAAAA;AAK/F,IAAME,aAAY,CAACb,WAAwCc,UAAWd,MAAAA;AAKtE,IAAMe,YAAW,CAACf,WAAmDgB,SAAUhB,MAAAA;AAK/E,IAAMiB,kBAAiB,CAACjB,WAAmDkB,eAAgBlB,MAAAA;AAK3F,IAAMmB,SAAS,CAACnB,WAAqCoB,aAAQpB,MAAAA;AAM7D,IAAMqB,aAAY,CAACrB,QAAiBsB,aAAAA;AACzC,SAAOC,UAAWvB,QAAQsB,QAAAA;AAC5B;AAmCO,IAAME,UAAS,CAAoBxB,QAAWsB,aAAAA;AACnDG,SAAQzB,QAAQsB,QAAAA;AAClB;AAMO,IAAMI,UAAS,CAAC1B,QAA0B2B,QAAsBC,OAAQ5B,QAAQ2B,GAAAA;AAMhF,IAAME,aAAY,CAAC7B,QAA0B2B,QAAsBG,UAAW9B,QAAQ2B,GAAAA;",
-  "names": ["addTag", "change", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "subscribe", "Kind", "EntityKind", "KindSchema", "EntityKindSchema", "getKind", "getEntityKind", "getDXN", "entity", "getDXN$", "getTypeDXN", "getTypeDXN$", "getTypename", "getTypename$", "getDatabase", "getDatabase$", "getMeta", "getMeta$", "getKeys", "source", "getKeys$", "isDeleted", "isDeleted$", "getLabel", "getLabel$", "getDescription", "getDescription$", "toJSON", "toJSON$", "subscribe", "callback", "subscribe$", "change", "change$", "addTag", "tag", "addTag$", "removeTag", "removeTag$"]
-}

package/dist/lib/neutral/chunk-CUDIBUM4.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 * 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 { 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"],
-  "mappings": "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",
-  "names": ["ATTR_TYPE", "TypeId", "Symbol", "for", "SchemaId", "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"]
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Ref.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { Ref as Ref$, RefArray, type RefResolver } from './internal';\nimport { getSchemaReference } from './internal';\nimport type * as JsonSchema from './JsonSchema';\nimport type * as Obj from './Obj';\n\nexport type Ref<T> = Ref$<T>;\nexport type Unknown = Ref$<Obj.Unknown>;\n\nexport const Array = RefArray;\n\n/**\n * Extract reference target.\n */\nexport type Target<R extends Unknown> = R extends Ref$<infer T> ? T : never;\n\n/**\n * Reference resolver.\n */\nexport type Resolver = RefResolver;\n\nexport const isRef: (value: unknown) => value is Unknown = Ref$.isRef;\n\nexport const make = Ref$.make;\n\n// TODO(dmaretskyi): Consider just allowing `make` to accept DXN.\nexport const fromDXN = Ref$.fromDXN;\n\n// TODO(wittjosiah): Factor out?\nexport const isRefType = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation<JsonSchema.JsonSchema>(ast, SchemaAST.JSONSchemaAnnotationId).pipe(\n    Option.flatMap((jsonSchema) => ('$id' in jsonSchema ? Option.some(jsonSchema) : Option.none())),\n    Option.flatMap((jsonSchema) => {\n      const { typename } = getSchemaReference(jsonSchema) ?? {};\n      return typename ? Option.some(true) : Option.some(false);\n    }),\n    Option.getOrElse(() => false),\n  );\n};\n"],
-  "mappings": ";;;;;;;;;;AAAA;;;;;;;;AAIA,YAAYA,YAAY;AACxB,YAAYC,eAAe;AAUpB,IAAMC,QAAQC;AAYd,IAAMC,QAA8CC,IAAKD;AAEzD,IAAME,OAAOD,IAAKC;AAGlB,IAAMC,UAAUF,IAAKE;AAGrB,IAAMC,YAAY,CAACC,QAAAA;AACxB,SAAiBC,wBAAqCD,KAAeE,gCAAsB,EAAEC,KACpFC,eAAQ,CAACC,eAAgB,SAASA,aAAoBC,YAAKD,UAAAA,IAAqBE,YAAI,CAAA,GACpFH,eAAQ,CAACC,eAAAA;AACd,UAAM,EAAEG,SAAQ,IAAKC,mBAAmBJ,UAAAA,KAAe,CAAC;AACxD,WAAOG,WAAkBF,YAAK,IAAA,IAAeA,YAAK,KAAA;EACpD,CAAA,GACOI,iBAAU,MAAM,KAAA,CAAA;AAE3B;",
-  "names": ["Option", "SchemaAST", "Array", "RefArray", "isRef", "Ref$", "make", "fromDXN", "isRefType", "ast", "getAnnotation", "JSONSchemaAnnotationId", "pipe", "flatMap", "jsonSchema", "some", "none", "typename", "getSchemaReference", "getOrElse"]
-}

package/dist/lib/neutral/chunk-IP2GHXWA.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 { LabelAnnotation, SystemTypeAnnotation } 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  LabelAnnotation.set(['label']),\n  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\n// TODO(burdon): Rename Map.\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,GACAC,gBAAgBC,IAAI;EAAC;CAAQ,GAC7BC,qBAAqBD,IAAI,IAAA,CAAA;AAKpB,IAAME,QAAO,CAACC,UAAyCD,KAAKb,KAAKc,KAAAA;AAKjE,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-KRHDMXSU.mjs

@@ -1,132 +0,0 @@
-import {
-  isInstanceOf
-} from "./chunk-CUDIBUM4.mjs";
-import {
-  ObjectNotFoundError
-} from "./chunk-RPB6V4BE.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Database.ts
-var Database_exports = {};
-__export(Database_exports, {
-  Database: () => Database,
-  Service: () => Service,
-  TypeId: () => TypeId,
-  isDatabase: () => isDatabase
-});
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schema from "effect/Schema";
-import { promiseWithCauseCapture } from "@dxos/effect";
-import { invariant } from "@dxos/invariant";
-import { DXN } from "@dxos/keys";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Database.ts";
-var TypeId = Symbol.for("@dxos/echo/Database");
-var isDatabase = (obj) => {
-  return obj ? typeof obj === "object" && TypeId in obj && obj[TypeId] === TypeId : false;
-};
-var Database = Schema.Any.pipe(Schema.filter((space) => isDatabase(space)));
-var Service = class _Service extends Context.Tag("@dxos/echo/Database/Service")() {
-  static notAvailable = Layer.succeed(_Service, {
-    get db() {
-      throw new Error("Database not available");
-    }
-  });
-  static make = (db) => {
-    return {
-      get db() {
-        return db;
-      }
-    };
-  };
-  static layer = (db) => {
-    return Layer.succeed(_Service, _Service.make(db));
-  };
-  // TODO(dmaretskyi): Move all those to the top-level API of Database.ts module.
-  /**
-  * Returns the space ID of the database.
-  */
-  static spaceId = Effect.gen(function* () {
-    const { db } = yield* _Service;
-    return db.spaceId;
-  });
-  /**
-  * Resolves an object by its DXN.
-  */
-  static resolve = (ref, schema) => Effect.gen(function* () {
-    const { db } = yield* _Service;
-    const dxn = ref instanceof DXN ? ref : ref.dxn;
-    const object = yield* promiseWithCauseCapture(() => db.graph.createRefResolver({
-      context: {
-        space: db.spaceId
-      }
-    }).resolve(dxn));
-    if (!object) {
-      return yield* Effect.fail(new ObjectNotFoundError(dxn));
-    }
-    invariant(!schema || isInstanceOf(schema, object), "Object type mismatch.", {
-      F: __dxlog_file,
-      L: 254,
-      S: this,
-      A: [
-        "!schema || isInstanceOf(schema, object)",
-        "'Object type mismatch.'"
-      ]
-    });
-    return object;
-  });
-  /**
-  * Loads an object reference.
-  */
-  static load = Effect.fn(function* (ref) {
-    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
-    if (!object) {
-      return yield* Effect.fail(new ObjectNotFoundError(ref.dxn));
-    }
-    return object;
-  });
-  /**
-  * Loads an object reference option.
-  */
-  // TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.
-  static loadOption = Effect.fn(function* (ref) {
-    const object = yield* _Service.load(ref).pipe(Effect.catchTag("ObjectNotFoundError", () => Effect.succeed(void 0)));
-    return Option.fromNullable(object);
-  });
-  /**
-  * @link EchoDatabase.add
-  */
-  static add = (obj) => _Service.pipe(Effect.map(({ db }) => db.add(obj)));
-  /**
-  * @link EchoDatabase.remove
-  */
-  static remove = (obj) => _Service.pipe(Effect.map(({ db }) => db.remove(obj)));
-  /**
-  * @link EchoDatabase.flush
-  */
-  static flush = (opts) => _Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
-  /**
-  * Creates a `QueryResult` object that can be subscribed to.
-  */
-  static query = (queryOrFilter) => _Service.pipe(Effect.map(({ db }) => db.query(queryOrFilter)), Effect.withSpan("Service.query"));
-  /**
-  * Executes the query once and returns the results.
-  */
-  static runQuery = (queryOrFilter) => _Service.query(queryOrFilter).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
-  // TODO(dmaretskyi): Change API to `yield* Service.querySchema(...).first` and `yield* Service.querySchema(...).schema`.
-  static schemaQuery = (query) => _Service.pipe(Effect.map(({ db }) => db.schemaRegistry.query(query)), Effect.withSpan("Service.schemaQuery"));
-  static runSchemaQuery = (query) => _Service.schemaQuery(query).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
-};
-
-export {
-  TypeId,
-  isDatabase,
-  Database,
-  Service,
-  Database_exports
-};
-//# sourceMappingURL=chunk-KRHDMXSU.mjs.map

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Database.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 * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\nimport { promiseWithCauseCapture } from '@dxos/effect';\nimport { invariant } from '@dxos/invariant';\nimport { DXN, type PublicKey, type SpaceId } from '@dxos/keys';\nimport { type QueryOptions as QueryOptionsProto } from '@dxos/protocols/proto/dxos/echo/filter';\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/annotations';\nimport type { Ref } from './internal/ref/ref';\nimport { type AnyProperties } from './internal/types';\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 * @deprecated Use `QueryAST.QueryOptions` instead.\n */\nexport type QueryOptions = {\n  /**\n   * @deprecated Use `spaceIds` instead.\n   */\n  spaces?: PublicKey[];\n\n  /**\n   * Query only in specific spaces.\n   */\n  // TODO(dmaretskyi): Change this to SpaceId.\n  spaceIds?: string[];\n\n  /**\n   * Return only the first `limit` results.\n   */\n  limit?: number;\n\n  /**\n   * Query only local spaces, or remote on agent.\n   * @default `QueryOptions.DataLocation.LOCAL`\n   *\n   * Options:\n   *   - proto3_optional = true\n   */\n  // TODO(burdon): Remove?\n  dataLocation?: QueryOptionsProto.DataLocation;\n};\n\n/**\n * `query` API function declaration.\n */\n// TODO(burdon): Reconcile Query and Filter (should only have one root type).\n// TODO(dmaretskyi): Remove query options.\nexport interface QueryFn {\n  <Q extends Query.Any>(\n    query: Q,\n    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,\n  ): QueryResult.QueryResult<Query.Type<Q>>;\n\n  <F extends Filter.Any>(\n    filter: F,\n    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,\n  ): 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 false\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.Obj<AnyProperties>>(id: string, opts?: GetObjectByIdOptions): 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\nexport class Service extends Context.Tag('@dxos/echo/Database/Service')<\n  Service,\n  {\n    readonly db: Database;\n  }\n>() {\n  static notAvailable = Layer.succeed(Service, {\n    get db(): Database {\n      throw new Error('Database not available');\n    },\n  });\n\n  static make = (db: Database): Context.Tag.Service<Service> => {\n    return {\n      get db() {\n        return db;\n      },\n    };\n  };\n\n  static layer = (db: Database): Layer.Layer<Service> => {\n    return Layer.succeed(Service, Service.make(db));\n  };\n\n  // TODO(dmaretskyi): Move all those to the top-level API of Database.ts module.\n\n  /**\n   * Returns the space ID of the database.\n   */\n  static spaceId = Effect.gen(function* () {\n    const { db } = yield* Service;\n    return db.spaceId;\n  });\n\n  /**\n   * Resolves an object by its DXN.\n   */\n  static resolve: {\n    // No type check.\n    (ref: DXN | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;\n    // Check matches schema.\n    <S extends Type.Entity.Any>(\n      ref: DXN | Ref<any>,\n      schema: S,\n    ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;\n  } = (<S extends Type.Entity.Any>(\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   */\n  static 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.\n  static loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {\n    const object = yield* Service.load(ref).pipe(\n      Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)),\n    );\n\n    return Option.fromNullable(object);\n  });\n\n  /**\n   * @link EchoDatabase.add\n   */\n  static add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>\n    Service.pipe(Effect.map(({ db }) => db.add(obj)));\n\n  /**\n   * @link EchoDatabase.remove\n   */\n  static remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>\n    Service.pipe(Effect.map(({ db }) => db.remove(obj)));\n\n  /**\n   * @link EchoDatabase.flush\n   */\n  static 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   */\n  static 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('Service.query'),\n    );\n\n  /**\n   * Executes the query once and returns the results.\n   */\n  static 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    Service.query(queryOrFilter as any).pipe(\n      Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),\n    );\n\n  // TODO(dmaretskyi): Change API to `yield* Service.querySchema(...).first` and `yield* Service.querySchema(...).schema`.\n\n  static schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n    query?: Q & SchemaRegistry.Query,\n  ): Effect.Effect<QueryResult.QueryResult<SchemaRegistry.ExtractQueryResult<Q>>, never, Service> =>\n    Service.pipe(\n      Effect.map(({ db }) => db.schemaRegistry.query(query)),\n      Effect.withSpan('Service.schemaQuery'),\n    );\n\n  static runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(\n    query?: Q & SchemaRegistry.Query,\n  ): Effect.Effect<SchemaRegistry.ExtractQueryResult<Q>[], never, Service> =>\n    Service.schemaQuery(query).pipe(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", "make", "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", "schemaQuery", "schemaRegistry", "runSchemaQuery"]
-}

package/dist/lib/neutral/chunk-NWUO5FKZ.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} from './internal/annotations';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;",
-  "names": []
-}

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

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Order.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nexport interface Order<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Order': { value: T };\n\n  ast: QueryAST.Order;\n}\n\nexport type Any = Order<any>;\n\nclass OrderClass implements Order<any> {\n  private static variance: Order<any>['~Order'] = {} as Order<any>['~Order'];\n\n  static is(value: unknown): value is Order<any> {\n    return typeof value === 'object' && value !== null && '~Order' in value;\n  }\n\n  constructor(public readonly ast: QueryAST.Order) {}\n\n  '~Order' = OrderClass.variance;\n}\n\nexport const natural: Order<any> = new OrderClass({ kind: 'natural' });\nexport const property = <T>(property: keyof T & string, direction: QueryAST.OrderDirection): Order<T> =>\n  new OrderClass({\n    kind: 'property',\n    property,\n    direction,\n  });\n\n/**\n * Order by relevance rank (for FTS/vector search results).\n * Higher rank = better match. Default direction is 'desc' (best matches first).\n */\nexport const rank = <T>(direction: QueryAST.OrderDirection = 'desc'): Order<T> =>\n  new OrderClass({\n    kind: 'rank',\n    direction,\n  });\n"],
-  "mappings": ";;;;;AAAA;;;;;;AAeA,IAAMA,aAAN,MAAMA,YAAAA;;EACJ,OAAeC,WAAiC,CAAC;EAEjD,OAAOC,GAAGC,OAAqC;AAC7C,WAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,YAAYA;EACpE;EAEA,YAA4BC,KAAqB;SAArBA,MAAAA;EAAsB;EAElD,WAAWJ,YAAWC;AACxB;AAEO,IAAMI,UAAsB,IAAIL,WAAW;EAAEM,MAAM;AAAU,CAAA;AAC7D,IAAMC,WAAW,CAAIA,WAA4BC,cACtD,IAAIR,WAAW;EACbM,MAAM;EACNC,UAAAA;EACAC;AACF,CAAA;AAMK,IAAMC,OAAO,CAAID,YAAqC,WAC3D,IAAIR,WAAW;EACbM,MAAM;EACNE;AACF,CAAA;",
-  "names": ["OrderClass", "variance", "is", "value", "ast", "natural", "kind", "property", "direction", "rank"]
-}

package/dist/lib/neutral/chunk-RPB6V4BE.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"],
-  "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;",
-  "names": ["BaseError", "SchemaNotFoundError", "BaseError", "extend", "schema", "options", "context", "ObjectNotFoundError", "dxn"]
-}