@dxos/echo 0.8.4-main.21d9917 → 0.8.4-main.2244d791bb

package/dist/lib/{node-esm/chunk-QYR67VBV.mjs.map → neutral/chunk-CH3HX4Z5.mjs.map}

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../src/Filter.ts"],
   "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport type * as Types from 'effect/Types';\n\nimport { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport { getTypeDXNFromSpecifier } from './internal';\nimport * as Ref from './Ref';\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Contravariant<T> };\n\n  ast: QueryAST.Filter;\n}\n\nexport type Props<T> = {\n  // Predicate or a value as a shorthand for `eq`.\n  [K in keyof T & string]?: Filter<T[K]> | T[K];\n};\n\nexport type Any = Filter<any>;\n\nexport type Type<F extends Any> = F extends Filter<infer T> ? T : never;\n\nclass FilterClass implements Any {\n  private static variance: Any['~Filter'] = {} as Any['~Filter'];\n\n  constructor(public readonly ast: QueryAST.Filter) {}\n\n  '~Filter' = FilterClass.variance;\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Filter' in value;\n};\n\n/** Construct a filter from an ast. */\nexport const fromAst = (ast: QueryAST.Filter): Any => {\n  return new FilterClass(ast);\n};\n\n/**\n * Filter that matches all objects.\n */\n// TODO(dmaretskyi): `Entity.Any` would be more type-safe, but causes annoying errors in existing code\nexport const everything = (): FilterClass => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n  });\n};\n\n/**\n * Filter that matches no objects.\n */\nexport const nothing = (): FilterClass => {\n  return new FilterClass({\n    type: 'not',\n    filter: {\n      type: 'object',\n      typename: null,\n      props: {},\n    },\n  });\n};\n\n/*\n * Filter by ObjectId.\n */\nexport const id = (...ids: ObjectId[]): Any => {\n  assertArgument(\n    ids.every((id) => ObjectId.isValid(id)),\n    'ids',\n    'ids must be valid',\n  );\n\n  if (ids.length === 0) {\n    return nothing();\n  }\n\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    id: ids,\n    props: {},\n  });\n};\n\n/**\n * Filter by type.\n */\nexport const type = <S extends Schema.Schema.All>(\n  schema: S | string,\n  props?: Props<Schema.Schema.Type<S>>,\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    ...propsFilterToAst(props ?? {}),\n  });\n};\n\n/**\n * Filter by non-qualified typename.\n */\nexport const typename = (typename: string): Any => {\n  assertArgument(!typename.startsWith('dxn:'), 'typename', 'Typename must no be qualified');\n  return new FilterClass({\n    type: 'object',\n    typename: DXN.fromTypename(typename).toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by fully qualified type DXN.\n */\nexport const typeDXN = (dxn: DXN): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n  });\n};\n\n/**\n * Filter by tag.\n */\nexport const tag = (tag: string): Any => {\n  return new FilterClass({\n    type: 'tag',\n    tag,\n  });\n};\n\n/**\n * Filter by properties.\n */\nexport const props = <T>(props: Props<T>): Filter<T> => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    ...propsFilterToAst(props),\n  });\n};\n\nexport type TextSearchOptions = {\n  // TODO(dmaretskyi): Hybrid search.\n  type?: 'full-text' | 'vector';\n};\n\n/**\n * Full-text or vector search.\n */\nexport const text = (\n  // TODO(dmaretskyi): Consider passing a vector here, but really the embedding should be done on the query-executor side.\n  text: string,\n  options?: TextSearchOptions,\n): Any => {\n  return new FilterClass({\n    type: 'text-search',\n    text,\n    searchKind: options?.type,\n  });\n};\n\n/**\n * Filter by foreign keys.\n */\nexport const foreignKeys = <S extends Schema.Schema.All>(\n  schema: S | string,\n  keys: ForeignKey[],\n): Filter<Schema.Schema.Type<S>> => {\n  const dxn = getTypeDXNFromSpecifier(schema);\n  return new FilterClass({\n    type: 'object',\n    typename: dxn.toString(),\n    props: {},\n    foreignKeys: keys,\n  });\n};\n\n/**\n * Predicate for property to be equal to the provided value.\n */\nexport const eq = <T>(value: T): Filter<T | undefined> => {\n  if (!Ref.isRef(value) && typeof value === 'object' && value !== null) {\n    throw new TypeError('Cannot use object as a value for eq filter');\n  }\n\n  return new FilterClass({\n    type: 'compare',\n    operator: 'eq',\n    value: Ref.isRef(value) ? value.noInline().encode() : value,\n  });\n};\n\n/**\n * Predicate for property to be not equal to the provided value.\n */\nexport const neq = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'neq',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than the provided value.\n */\nexport const gt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be greater than or equal to the provided value.\n */\nexport const gte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'gte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than the provided value.\n */\nexport const lt = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lt',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be less than or equal to the provided value.\n */\nexport const lte = <T>(value: T): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'compare',\n    operator: 'lte',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided array.\n * @param values - Values to check against.\n */\nconst in$ = <T>(...values: T[]): Filter<T | undefined> => {\n  return new FilterClass({\n    type: 'in',\n    values,\n  });\n};\nexport { in$ as in };\n\n/**\n * Predicate for an array property to contain the provided value.\n * @param value - Value to check against.\n */\nexport const contains = <T>(value: T): Filter<readonly T[] | undefined> => {\n  return new FilterClass({\n    type: 'contains',\n    value,\n  });\n};\n\n/**\n * Predicate for property to be in the provided range.\n * @param from - Start of the range (inclusive).\n * @param to - End of the range (exclusive).\n */\nexport const between = <T>(from: T, to: T): Filter<unknown> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\n/**\n * Negate the filter.\n */\nexport const not = <F extends Any>(filter: F): Filter<Type<F>> => {\n  return new FilterClass({\n    type: 'not',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Combine filters with a logical AND.\n */\nexport const and = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'and',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n/**\n * Combine filters with a logical OR.\n */\nexport const or = <Filters extends readonly Any[]>(...filters: Filters): Filter<Type<Filters[number]>> => {\n  return new FilterClass({\n    type: 'or',\n    filters: filters.map((f) => f.ast),\n  });\n};\n\n// TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.\n\nconst propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {\n  let idFilter: readonly ObjectId[] | undefined;\n  if ('id' in predicates) {\n    assertArgument(\n      typeof predicates.id === 'string' || Array.isArray(predicates.id),\n      'predicates.id',\n      'invalid id filter',\n    );\n    idFilter = typeof predicates.id === 'string' ? [predicates.id] : predicates.id;\n    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);\n  }\n\n  return {\n    id: idFilter,\n    props: Object.fromEntries(\n      Object.entries(predicates)\n        .filter(([prop, _value]) => prop !== 'id')\n        .map(([prop, predicate]) => [prop, processPredicate(predicate)]),\n    ) as Record<string, QueryAST.Filter>,\n  };\n};\n\nconst processPredicate = (predicate: any): QueryAST.Filter => {\n  return Match.value(predicate).pipe(\n    Match.withReturnType<QueryAST.Filter>(),\n    Match.when(is, (predicate) => predicate.ast),\n    // TODO(wittjosiah): Add support for array predicates.\n    Match.when(Array.isArray, (_predicate) => {\n      throw new Error('Array predicates are not yet supported.');\n    }),\n    Match.when(\n      (predicate: any) => !Ref.isRef(predicate) && typeof predicate === 'object' && predicate !== null,\n      (predicate) => {\n        const nestedProps = Object.fromEntries(\n          Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]),\n        );\n\n        return {\n          type: 'object',\n          typename: null,\n          props: nestedProps,\n        };\n      },\n    ),\n    Match.orElse((value) => eq(value).ast),\n  );\n};\n"],
-  "mappings": "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",
+  "mappings": "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",
   "names": ["Match", "Schema", "assertArgument", "DXN", "ObjectId", "FilterClass", "variance", "ast", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "ObjectId", "isValid", "length", "schema", "dxn", "getTypeDXNFromSpecifier", "toString", "propsFilterToAst", "startsWith", "DXN", "fromTypename", "typeDXN", "tag", "text", "options", "searchKind", "foreignKeys", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in$", "values", "contains", "value", "FilterClass", "type", "between", "from", "to", "not", "filter", "ast", "and", "filters", "map", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Array", "isArray", "Schema", "ObjectId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "isRef", "nestedProps", "key", "typename", "orElse", "eq"]
 }

package/dist/lib/{browser/chunk-CGS2ULMK.mjs → neutral/chunk-J5LGTIGS.mjs}

@@ -1,4 +1,3 @@
-import "@dxos/node-std/globals";
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -8,4 +7,4 @@ var __export = (target, all) => {
 export {
   __export
 };
-//# sourceMappingURL=chunk-CGS2ULMK.mjs.map
+//# sourceMappingURL=chunk-J5LGTIGS.mjs.map

package/dist/lib/{browser/chunk-YKTSSMDS.mjs → neutral/chunk-KB7RIVLK.mjs}

@@ -1,5 +1,3 @@
-import "@dxos/node-std/globals";
-
 // src/internal/types/entity.ts
 import * as Schema from "effect/Schema";
 var KindId = "~@dxos/echo/Kind";
@@ -66,4 +64,4 @@ export {
   unwrapOptional,
   makeTypeJsonSchemaAnnotation
 };
-//# sourceMappingURL=chunk-YKTSSMDS.mjs.map
+//# sourceMappingURL=chunk-KB7RIVLK.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/types/entity.ts", "../../../src/internal/annotations/util.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\n// NOTE: String literals are used instead of unique symbols for both KindId and SchemaKindId.\n//   Unique symbols cause TS4023 \"cannot be named\" errors when external packages\n//   try to export types that reference this key (e.g., `export const Graph = ...`).\n//   TypeScript cannot emit declaration files that reference unique symbols from\n//   external modules. Using a string literal allows the type to be inlined in\n//   declaration files, making the API portable across package boundaries.\n\n/**\n * String key used to identify the kind of an entity instance (object or relation).\n */\nexport const KindId = '~@dxos/echo/Kind' as const;\nexport type KindId = typeof KindId;\n\n/**\n * String key used to identify the kind of a schema (object schema or relation schema).\n * Parallels KindId which identifies instance kinds.\n */\nexport const SchemaKindId = '~@dxos/echo/SchemaKind' as const;\nexport type SchemaKindId = typeof SchemaKindId;\n\n/**\n * String key used to brand snapshot types.\n * Snapshots have SnapshotKindId instead of KindId, making them\n * distinguishable from reactive objects at the type level.\n */\nexport const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;\nexport type SnapshotKindId = typeof SnapshotKindId;\n\n/**\n * Kinds of entities stored in ECHO: objects and relations.\n */\nexport enum EntityKind {\n  Object = 'object',\n  Relation = 'relation',\n}\n\nexport const EntityKindSchema = Schema.Enums(EntityKind);\n\n/**\n * Typename for generic object references (Type.Obj / Type.Ref(Type.Obj)).\n * Used when referencing any object without a specific schema.\n */\nexport const ANY_OBJECT_TYPENAME = 'dxos.org/schema/AnyObject';\n\n/**\n * Version for generic object references.\n */\nexport const ANY_OBJECT_VERSION = '0.0.0';\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Option from 'effect/Option';\nimport type * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { assertArgument } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\n\nimport { EntityKind } from '../types';\n\nexport interface AnnotationHelper<T> {\n  /**\n   * Get the annotation value from the schema.\n   */\n  get: (schema: Schema.Schema.Any) => Option.Option<T>;\n  /**\n   * Get the annotation value from the AST.\n   */\n  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;\n  /**\n   * Set the annotation value on the schema.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\n/**\n * Note: only for system annotations.\n */\n// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.\nexport const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {\n  return {\n    get: (schema) => SchemaAST.getAnnotation(schema.ast, id),\n    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),\n    set:\n      (value) =>\n      <S extends Schema.Schema.Any>(schema: S) =>\n        schema.annotations({ [id]: value }) as S,\n  };\n};\n\n/**\n * If property is optional returns the nested property, otherwise returns the property.\n */\n// TODO(wittjosiah): Is there a way to do this as a generic?\nexport const unwrapOptional = (property: SchemaAST.PropertySignature) => {\n  if (!property.isOptional || !SchemaAST.isUnion(property.type)) {\n    return property;\n  }\n\n  return property.type.types[0];\n};\n\n/**\n * @see JSONSchemaAnnotationId\n * @returns JSON-schema annotation so that the schema can be serialized with correct parameters.\n */\n// TODO(burdon): Required type.\nexport const makeTypeJsonSchemaAnnotation = (options: {\n  identifier?: string;\n  kind: EntityKind;\n  typename: string;\n  version: string;\n  relationSource?: string;\n  relationTarget?: string;\n}) => {\n  assertArgument(!!options.relationSource === (options.kind === EntityKind.Relation), 'relationSource');\n  assertArgument(!!options.relationTarget === (options.kind === EntityKind.Relation), 'relationTarget');\n\n  const obj = {\n    // TODO(dmaretskyi): Should this include the version?\n    $id: options.identifier ?? DXN.fromTypename(options.typename).toString(),\n    entityKind: options.kind,\n    version: options.version,\n    typename: options.typename,\n  } as any;\n  if (options.kind === EntityKind.Relation) {\n    obj.relationSource = { $ref: options.relationSource };\n    obj.relationTarget = { $ref: options.relationTarget };\n  }\n\n  return obj;\n};\n"],
+  "mappings": ";AAIA,YAAYA,YAAY;AAYjB,IAAMC,SAAS;AAOf,IAAMC,eAAe;AAQrB,IAAMC,iBAAiB;AAMvB,IAAKC,aAAAA,0BAAAA,aAAAA;;;SAAAA;;AAKL,IAAMC,mBAA0BC,aAAMF,UAAAA;AAMtC,IAAMG,sBAAsB;AAK5B,IAAMC,qBAAqB;;;AC/ClC,YAAYC,eAAe;AAE3B,SAASC,sBAAsB;AAC/B,SAASC,WAAW;AAuBb,IAAMC,yBAAyB,CAAIC,OAAAA;AACxC,SAAO;IACLC,KAAK,CAACC,WAAqBC,wBAAcD,OAAOE,KAAKJ,EAAAA;IACrDK,YAAY,CAACD,QAAkBD,wBAAcC,KAAKJ,EAAAA;IAClDM,KACE,CAACC,UACD,CAA8BL,WAC5BA,OAAOM,YAAY;MAAE,CAACR,EAAAA,GAAKO;IAAM,CAAA;EACvC;AACF;AAMO,IAAME,iBAAiB,CAACC,aAAAA;AAC7B,MAAI,CAACA,SAASC,cAAc,CAAWC,kBAAQF,SAASG,IAAI,GAAG;AAC7D,WAAOH;EACT;AAEA,SAAOA,SAASG,KAAKC,MAAM,CAAA;AAC7B;AAOO,IAAMC,+BAA+B,CAACC,YAAAA;AAQ3CC,iBAAe,CAAC,CAACD,QAAQE,oBAAoBF,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AACpFJ,iBAAe,CAAC,CAACD,QAAQM,oBAAoBN,QAAQG,SAASC,WAAWC,WAAW,gBAAA;AAEpF,QAAME,MAAM;;IAEVC,KAAKR,QAAQS,cAAcC,IAAIC,aAAaX,QAAQY,QAAQ,EAAEC,SAAQ;IACtEC,YAAYd,QAAQG;IACpBY,SAASf,QAAQe;IACjBH,UAAUZ,QAAQY;EACpB;AACA,MAAIZ,QAAQG,SAASC,WAAWC,UAAU;AACxCE,QAAIL,iBAAiB;MAAEc,MAAMhB,QAAQE;IAAe;AACpDK,QAAID,iBAAiB;MAAEU,MAAMhB,QAAQM;IAAe;EACtD;AAEA,SAAOC;AACT;",
+  "names": ["Schema", "KindId", "SchemaKindId", "SnapshotKindId", "EntityKind", "EntityKindSchema", "Enums", "ANY_OBJECT_TYPENAME", "ANY_OBJECT_VERSION", "SchemaAST", "assertArgument", "DXN", "createAnnotationHelper", "id", "get", "schema", "getAnnotation", "ast", "getFromAst", "set", "value", "annotations", "unwrapOptional", "property", "isOptional", "isUnion", "type", "types", "makeTypeJsonSchemaAnnotation", "options", "assertArgument", "relationSource", "kind", "EntityKind", "Relation", "relationTarget", "obj", "$id", "identifier", "DXN", "fromTypename", "typename", "toString", "entityKind", "version", "$ref"]
+}

package/dist/lib/{browser/chunk-2SBB7OWV.mjs → neutral/chunk-KSFI2POM.mjs}

@@ -1,4 +1,3 @@
-import "@dxos/node-std/globals";
 import {
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
@@ -32,21 +31,22 @@ import {
   sortByTypename,
   subscribe,
   version
-} from "./chunk-BJPE6CIC.mjs";
+} from "./chunk-ZUG3PNXU.mjs";
 import {
+  ParentId,
   getSchema,
   getTypeAnnotation,
   getTypeDXN,
   getTypename
-} from "./chunk-RK4Z4JUZ.mjs";
+} from "./chunk-RIMHNJ3E.mjs";
 import {
   EntityKind,
   KindId,
   SnapshotKindId
-} from "./chunk-YKTSSMDS.mjs";
+} from "./chunk-KB7RIVLK.mjs";
 import {
   __export
-} from "./chunk-CGS2ULMK.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/Relation.ts
 var Relation_exports = {};
@@ -97,6 +97,7 @@ var Source = RelationSourceId;
 var Target = RelationTargetId;
 var make = (schema, props, meta) => {
   assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, "schema", "Expected a relation schema");
+  assertArgument(props[ParentId] === void 0, "props", "Parent is not allowed for relations");
   if (props[MetaId] != null) {
     meta = props[MetaId];
     delete props[MetaId];
@@ -123,7 +124,7 @@ var getSourceDXN = (value) => {
   const dxn = value[RelationSourceDXNId];
   invariant(dxn instanceof DXN, void 0, {
     F: __dxlog_file,
-    L: 188,
+    L: 190,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -138,7 +139,7 @@ var getTargetDXN = (value) => {
   const dxn = value[RelationTargetDXNId];
   invariant(dxn instanceof DXN, void 0, {
     F: __dxlog_file,
-    L: 201,
+    L: 203,
     S: void 0,
     A: [
       "dxn instanceof DXN",
@@ -153,7 +154,7 @@ var getSource = (relation) => {
   const obj = relation[RelationSourceId];
   invariant(obj !== void 0, `Invalid source: ${relation.id}`, {
     F: __dxlog_file,
-    L: 214,
+    L: 216,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -168,7 +169,7 @@ var getTarget = (relation) => {
   const obj = relation[RelationTargetId];
   invariant(obj !== void 0, `Invalid target: ${relation.id}`, {
     F: __dxlog_file,
-    L: 227,
+    L: 229,
     S: void 0,
     A: [
       "obj !== undefined",
@@ -247,4 +248,4 @@ export {
   version2 as version,
   Relation_exports
 };
-//# sourceMappingURL=chunk-2SBB7OWV.mjs.map
+//# sourceMappingURL=chunk-KSFI2POM.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Relation.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\nimport { raise } from '@dxos/debug';\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath, getValue as getValue$ } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, type ObjectId } from '@dxos/keys';\nimport { assumeType } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport {\n  type ObjectJSON as APIJSON,\n  ATTR_RELATION_SOURCE,\n  ATTR_RELATION_TARGET,\n  type AnyEntity,\n  type Comparator as ApiComparator,\n  type Meta as ApiMeta,\n  type ReadonlyMeta as ApiReadonlyMeta,\n  type EntityVersion as ApiVersion,\n  type ChangeCallback,\n  EntityKind,\n  type InternalObjectProps,\n  type KindId,\n  MetaId,\n  type Mutable,\n  type ObjectMeta,\n  ParentId,\n  RelationSourceDXNId,\n  RelationSourceId,\n  RelationTargetDXNId,\n  RelationTargetId,\n  SnapshotKindId,\n  VersionTypeId,\n  addTag as addTag$,\n  change as change$,\n  deleteKeys as deleteKeys$,\n  getDXN as getDXN$,\n  getDatabase as getDatabase$,\n  getDescription as getDescription$,\n  getKeys as getKeys$,\n  getLabel as getLabel$,\n  getMetaChecked as getMeta$,\n  getObjectDXN,\n  getSchema as getSchema$,\n  getSnapshot as getSnapshot$,\n  getTypeAnnotation,\n  getTypeDXN as getTypeDXN$,\n  getTypename as getTypename$,\n  isDeleted as isDeleted$,\n  isVersion,\n  makeObject,\n  removeTag as removeTag$,\n  setDescription as setDescription$,\n  setLabel as setLabel$,\n  setValue as setValue$,\n  sort as sort$,\n  sortByLabel as sortByLabel$,\n  sortByTypename as sortByTypename$,\n  subscribe as subscribe$,\n  objectToJSON as toJSON$,\n  version as version$,\n} from './internal';\nimport type * as Obj from './Obj';\nimport type * as Type from './Type';\n\n/**\n * Base type for all ECHO relations.\n * @private\n */\ninterface BaseRelation<Source, Target>\n  extends AnyEntity,\n    Type.Relation.Endpoints<Source, Target>,\n    Entity.OfKind<EntityKind.Relation> {}\n\n/**\n * Relation with no known properties beyond id, kind, source, and target.\n * Use this when the relation's schema/properties are not known.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO relation, use `Relation.isRelation`.\n */\nexport interface Unknown extends BaseRelation<Obj.Unknown, Obj.Unknown> {}\n\n/**\n * Relation type with specific source and target types.\n */\nexport type Relation<Source extends Obj.Unknown, Target extends Obj.Unknown, Props> = BaseRelation<Source, Target> &\n  Props;\n\n/**\n * Base type for snapshot relations (has SnapshotKindId instead of KindId).\n */\ninterface BaseRelationSnapshot<Source, Target> extends AnyEntity, Type.Relation.Endpoints<Source, Target> {\n  readonly [SnapshotKindId]: EntityKind.Relation;\n  readonly id: ObjectId;\n}\n\n/**\n * Immutable snapshot of an ECHO relation.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, KindId> & BaseRelationSnapshot<Obj.Unknown, Obj.Unknown>;\n\nexport const Source: unique symbol = RelationSourceId as any;\nexport type Source = typeof Source;\n\nexport const Target: unique symbol = RelationTargetId as any;\nexport type Target = typeof Target;\n\n/**\n * Internal props type for relation instance creation.\n */\ntype RelationMakeProps<T extends Unknown> = {\n  id?: ObjectId;\n  [MetaId]?: ObjectMeta;\n  [Source]: T[Source];\n  [Target]: T[Target];\n} & Type.Properties<T>;\n\n/**\n * Props type for relation creation with a given schema.\n * Takes a schema type (created with Type.Relation) and extracts the props type.\n */\nexport type MakeProps<S extends Type.Relation.Any> = RelationMakeProps<Schema.Schema.Type<S>>;\n\n/**\n * Creates new relation.\n * @param schema - Relation schema.\n * @param props - Relation properties. Endpoints are passed as [Relation.Source] and [Relation.Target] keys.\n * @param meta - Relation metadata. (deprecated; use [Obj.Meta] instead)\n * @returns\n */\n// NOTE: Writing the definition this way (with generic over schema) makes typescript perfer to infer the type from the first param (this schema) rather than the second param (the props).\n// TODO(dmaretskyi): Move meta into props.\nexport const make = <S extends Type.Relation.Any>(\n  schema: S,\n  props: NoInfer<RelationMakeProps<Schema.Schema.Type<S>>>,\n  meta?: ObjectMeta,\n): Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation> => {\n  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, 'schema', 'Expected a relation schema');\n  assertArgument(props[ParentId] === undefined, 'props', 'Parent is not allowed for relations');\n\n  if (props[MetaId] != null) {\n    meta = props[MetaId] as any;\n    delete props[MetaId];\n  }\n\n  const sourceDXN = getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));\n  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));\n\n  (props as any)[RelationSourceDXNId] = sourceDXN;\n  (props as any)[RelationTargetDXNId] = targetDXN;\n\n  return makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);\n};\n\n/**\n * Type guard for relations.\n * Returns true for both reactive relations and relation snapshots.\n */\nexport const isRelation = (value: unknown): value is Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {\n    return true;\n  }\n\n  // Check for reactive relation (KindId) or snapshot (SnapshotKindId).\n  const kind = (value as any)[Entity.KindId] ?? (value as any)[SnapshotKindId];\n  return kind === EntityKind.Relation;\n};\n\n/**\n * @returns Relation source DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSourceDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[RelationSourceDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation target DXN.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTargetDXN = (value: Unknown | Snapshot): DXN => {\n  assertArgument(isRelation(value), 'Expected a relation');\n  assumeType<InternalObjectProps>(value);\n  const dxn = (value as InternalObjectProps)[RelationTargetDXNId];\n  invariant(dxn instanceof DXN);\n  return dxn;\n};\n\n/**\n * @returns Relation source.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getSource = <T extends Unknown | Snapshot>(relation: T): Type.Relation.Source<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[RelationSourceId];\n  invariant(obj !== undefined, `Invalid source: ${relation.id}`);\n  return obj as Type.Relation.Source<T>;\n};\n\n/**\n * @returns Relation target.\n * Accepts both reactive relations and snapshots.\n * @throws If the object is not a relation.\n */\nexport const getTarget = <T extends Unknown | Snapshot>(relation: T): Type.Relation.Target<T> => {\n  assertArgument(isRelation(relation), 'Expected a relation');\n  assumeType<InternalObjectProps>(relation);\n  const obj = (relation as InternalObjectProps)[RelationTargetId];\n  invariant(obj !== undefined, `Invalid target: ${relation.id}`);\n  return obj as Type.Relation.Target<T>;\n};\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of a relation within `Relation.change`.\n */\nexport type { Mutable };\n\n/**\n * Perform mutations on an echo relation within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Relation.change` will throw\n * an error for echo relations.\n *\n * @param relation - The echo relation to mutate. Use `Obj.change` for objects.\n * @param callback - The callback that performs mutations on the relation.\n *\n * @example\n * ```ts\n * const worksFor = Relation.make(EmployedBy, {\n *   [Relation.Source]: person,\n *   [Relation.Target]: company,\n *   role: 'Engineer',\n * });\n *\n * // Mutate within Relation.change\n * Relation.change(worksFor, (r) => {\n *   r.role = 'Senior Engineer';\n * });\n * ```\n *\n * Note: Only accepts relations. Use `Obj.change` for objects.\n */\nexport const change = <T extends Unknown>(relation: T, callback: ChangeCallback<T>): void => {\n  change$(relation, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of a relation.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive relation at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(rel: T) => Snapshot<T> = getSnapshot$ as any;\n\n//\n// Subscribe\n//\n\n/**\n * Subscribe to relation updates.\n * The callback is called synchronously when the relation is modified.\n * Only accepts reactive relations (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (rel: Unknown, callback: () => void): (() => void) => {\n  return subscribe$(rel, callback);\n};\n\n//\n// Property Access\n//\n\n/**\n * Get a deeply nested property from a relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getValue = (rel: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return getValue$(rel, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on a relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setValue: (rel: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  setValue$ as any;\n\n//\n// Type\n//\n\n/**\n * Get the DXN of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => getDXN$(entity);\n\n/**\n * @returns The DXN of the relation's type.\n */\nexport const getTypeDXN = getTypeDXN$;\n\n/**\n * Get the schema of the relation.\n * Returns the branded ECHO schema used to create the relation.\n */\nexport const getSchema: (rel: unknown | undefined) => Type.Entity.Any | undefined = getSchema$ as any;\n\n/**\n * @returns The typename of the relation's type.\n * Accepts both reactive relations and snapshots.\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => getTypename$(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the relation belongs to.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDatabase = (entity: Unknown | Snapshot): Database.Database | undefined => getDatabase$(entity);\n\n//\n// Meta\n//\n\n/**\n * Deeply read-only version of ObjectMeta.\n */\nexport type ReadonlyMeta = ApiReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Relation.getMeta` inside a `Relation.change` callback.\n */\nexport type Meta = ApiMeta;\n\n/**\n * Get the metadata for a relation.\n * Returns mutable meta when passed a mutable relation (inside `Relation.change` callback).\n * Returns read-only meta when passed a regular relation 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>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return getMeta$(entity);\n}\n\n/**\n * @returns Foreign keys for the relation from the specified source.\n * Accepts both reactive relations and snapshots.\n */\nexport const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => getKeys$(entity, source);\n\n/**\n * Delete all keys from the relation for the specified source.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => deleteKeys$(entity, source);\n\n/**\n * Add a tag to the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => addTag$(entity, tag);\n\n/**\n * Remove a tag from the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => removeTag$(entity, tag);\n\n/**\n * Check if the relation is deleted.\n * Accepts both reactive relations and snapshots.\n */\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => isDeleted$(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => getLabel$(entity);\n\n/**\n * Set the label of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => setLabel$(entity, label);\n\n/**\n * Get the description of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => getDescription$(entity);\n\n/**\n * Set the description of the relation.\n * Must be called within a `Relation.change` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  setDescription$(entity, description);\n\n//\n// JSON\n//\n\n/**\n * JSON representation of a relation.\n */\nexport type JSON = APIJSON;\n\n/**\n * Converts relation to its JSON representation.\n * Accepts both reactive relations and snapshots.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => toJSON$(entity);\n\n//\n// Sorting\n//\n\n/**\n * Comparator function type for sorting relations.\n * Accepts both reactive relations and snapshots.\n */\nexport type Comparator = ApiComparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = sortByLabel$ as Comparator;\nexport const sortByTypename: Comparator = sortByTypename$ as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => sort$(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport { VersionTypeId, isVersion };\n\n/**\n * Represent relation version.\n */\nexport type Version = ApiVersion;\n\n/**\n * Returns the version of the relation.\n * Accepts both reactive relations and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => version$(entity);\n"],
+  "mappings": "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",
+  "names": ["addTag", "change", "deleteKeys", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "isDeleted", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "raise", "createJsonPath", "getValue", "getValue$", "assertArgument", "invariant", "DXN", "assumeType", "Source", "RelationSourceId", "Target", "RelationTargetId", "make", "schema", "props", "meta", "assertArgument", "getTypeAnnotation", "kind", "EntityKind", "Relation", "ParentId", "undefined", "MetaId", "sourceDXN", "getObjectDXN", "raise", "Error", "targetDXN", "RelationSourceDXNId", "RelationTargetDXNId", "makeObject", "isRelation", "value", "ATTR_RELATION_SOURCE", "ATTR_RELATION_TARGET", "KindId", "SnapshotKindId", "getSourceDXN", "assumeType", "dxn", "invariant", "DXN", "getTargetDXN", "getSource", "relation", "obj", "id", "getTarget", "change", "callback", "change$", "getSnapshot", "getSnapshot$", "subscribe", "rel", "subscribe$", "getValue", "path", "getValue$", "createJsonPath", "setValue", "setValue$", "getDXN", "entity", "getDXN$", "getTypeDXN", "getTypeDXN$", "getSchema", "getSchema$", "getTypename", "getTypename$", "getDatabase", "getDatabase$", "getMeta", "getMeta$", "getKeys", "source", "getKeys$", "deleteKeys", "deleteKeys$", "addTag", "tag", "addTag$", "removeTag", "removeTag$", "isDeleted", "isDeleted$", "getLabel", "getLabel$", "setLabel", "label", "setLabel$", "getDescription", "getDescription$", "setDescription", "description", "setDescription$", "toJSON", "toJSON$", "sortByLabel", "sortByLabel$", "sortByTypename", "sortByTypename$", "sort", "comparators", "sort$", "version", "entity", "version$"]
+}

package/dist/lib/{browser/chunk-6L5HHUVU.mjs → neutral/chunk-LKQBTRJX.mjs}

@@ -1,15 +1,14 @@
-import "@dxos/node-std/globals";
 import {
   is,
   props,
   type
-} from "./chunk-ZAGAOZVY.mjs";
+} from "./chunk-CH3HX4Z5.mjs";
 import {
   getTypeDXNFromSpecifier
-} from "./chunk-RK4Z4JUZ.mjs";
+} from "./chunk-RIMHNJ3E.mjs";
 import {
   __export
-} from "./chunk-CGS2ULMK.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/Query.ts
 var Query_exports = {};
@@ -89,6 +88,20 @@ var QueryClass = class _QueryClass {
       direction: "target"
     });
   }
+  parent() {
+    return new _QueryClass({
+      type: "hierarchy-traversal",
+      anchor: this.ast,
+      direction: "to-parent"
+    });
+  }
+  children() {
+    return new _QueryClass({
+      type: "hierarchy-traversal",
+      anchor: this.ast,
+      direction: "to-children"
+    });
+  }
   orderBy(...order) {
     return new _QueryClass({
       type: "order",
@@ -155,4 +168,4 @@ export {
   without,
   Query_exports
 };
-//# sourceMappingURL=chunk-6L5HHUVU.mjs.map
+//# sourceMappingURL=chunk-LKQBTRJX.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Query.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as EffectArray from 'effect/Array';\nimport type * as Schema from 'effect/Schema';\n\nimport { type QueryAST } from '@dxos/echo-protocol';\n\nimport * as Filter from './Filter';\nimport { getTypeDXNFromSpecifier } from './internal';\nimport type * as Order from './Order';\nimport type * as Ref from './Ref';\nimport type * as Type$ from './Type';\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<Type$.Relation.Source<T>>;\n\n  /**\n   * For a query for relations, get the target objects.\n   * @returns Query for the target objects.\n   */\n  target(): Query<Type$.Relation.Target<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   * 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 ? 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: Filter.type(relation, predicates).ast,\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: Filter.type(relation, predicates).ast,\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  options(options: QueryAST.QueryOptions): Any {\n    return new QueryClass({\n      type: 'options',\n      query: this.ast,\n      options,\n    });\n  }\n}\n\nexport const is = (value: unknown): value is Any => {\n  return typeof value === 'object' && value !== null && '~Query' in value;\n};\n\n/** Construct a query from an ast. */\nexport const fromAst = (ast: QueryAST.Query): Any => {\n  return new QueryClass(ast);\n};\n\n/**\n * Select objects based on a filter.\n * @param filter - Filter to select the objects.\n * @returns Query for the selected objects.\n */\nexport const select = <F extends Filter.Any>(filter: F): Query<Filter.Type<F>> => {\n  return new QueryClass({\n    type: 'select',\n    filter: filter.ast,\n  });\n};\n\n/**\n * Query for objects of a given schema.\n * @param schema - Schema of the objects.\n * @param predicates - Predicates to filter the objects.\n * @returns Query for the objects.\n *\n * Shorthand for: `Query.select(Filter.type(schema, predicates))`.\n */\nexport const type = (schema: Schema.Schema.All | string, predicates?: Filter.Props<unknown>): Any => {\n  return new QueryClass({\n    type: 'select',\n    filter: Filter.type(schema, predicates).ast,\n  });\n};\n\n/**\n * Combine results of multiple queries.\n * @param queries - Queries to combine.\n * @returns Query for the combined results.\n */\n// TODO(dmaretskyi): Rename to `combine` or `union`.\nexport const all = (...queries: Any[]): Any => {\n  if (queries.length === 0) {\n    throw new TypeError(\n      'Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())',\n    );\n  }\n  return new QueryClass({\n    type: 'union',\n    queries: queries.map((q) => q.ast),\n  });\n};\n\n/**\n * Subtract one query from another.\n * @param source - Query to subtract from.\n * @param exclude - Query to subtract.\n * @returns Query for the results of the source query minus the results of the exclude query.\n */\nexport const without = <T>(source: Query<T>, exclude: Query<T>): Query<T> => {\n  return new QueryClass({\n    type: 'set-difference',\n    source: source.ast,\n    exclude: exclude.ast,\n  });\n};\n"],
+  "mappings": "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",
+  "names": ["is", "type", "QueryClass", "variance", "ast", "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", "options", "value", "fromAst", "schema", "all", "queries", "length", "TypeError", "q", "without", "exclude"]
+}

package/dist/lib/{browser/chunk-CJ5YELTO.mjs → neutral/chunk-MXQJZCPY.mjs}

@@ -1,11 +1,11 @@
-import "@dxos/node-std/globals";
 import {
   __export
-} from "./chunk-CGS2ULMK.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/Err.ts
 var Err_exports = {};
 __export(Err_exports, {
+  GetReactiveError: () => GetReactiveError,
   ObjectNotFoundError: () => ObjectNotFoundError,
   SchemaNotFoundError: () => SchemaNotFoundError
 });
@@ -30,10 +30,22 @@ var ObjectNotFoundError = class extends BaseError.extend("ObjectNotFoundError",
     });
   }
 };
+var GetReactiveError = class extends BaseError.extend("GetReactiveError", "Failed to get reactive object from snapshot") {
+  constructor(options) {
+    super({
+      context: {
+        reason: options.reason,
+        snapshotId: options.snapshotId
+      },
+      ...options
+    });
+  }
+};
 
 export {
   SchemaNotFoundError,
   ObjectNotFoundError,
+  GetReactiveError,
   Err_exports
 };
-//# sourceMappingURL=chunk-CJ5YELTO.mjs.map
+//# sourceMappingURL=chunk-MXQJZCPY.mjs.map

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

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

package/dist/lib/{browser/chunk-PQZW3S6L.mjs → neutral/chunk-N2QNHMT5.mjs}

@@ -1,4 +1,3 @@
-import "@dxos/node-std/globals";
 import {
   Currency,
   CurrencyAnnotationId,
@@ -29,10 +28,10 @@ import {
   getOptionsAnnotation,
   getTypeEnum,
   typeToFormat
-} from "./chunk-FRDT7RA4.mjs";
+} from "./chunk-7WE7SBA2.mjs";
 import {
   __export
-} from "./chunk-CGS2ULMK.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/Format.ts
 var Format_exports = {};
@@ -71,4 +70,4 @@ __export(Format_exports, {
 export {
   Format_exports
 };
-//# sourceMappingURL=chunk-PQZW3S6L.mjs.map
+//# sourceMappingURL=chunk-N2QNHMT5.mjs.map

package/dist/lib/{node-esm/chunk-Y75VU7LB.mjs.map → neutral/chunk-N2QNHMT5.mjs.map}

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

package/dist/lib/{browser/chunk-IXVWLTG7.mjs → neutral/chunk-OMUPQMLR.mjs}

@@ -1,9 +1,7 @@
-import "@dxos/node-std/globals";
-
 // src/QueryResult.ts
 var QueryResult_exports = {};
 
 export {
   QueryResult_exports
 };
-//# sourceMappingURL=chunk-IXVWLTG7.mjs.map
+//# sourceMappingURL=chunk-OMUPQMLR.mjs.map

package/dist/lib/{browser/chunk-IXVWLTG7.mjs.map → neutral/chunk-OMUPQMLR.mjs.map}

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../src/QueryResult.ts"],
   "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport { type CleanupFn } from '@dxos/async';\n\nimport type * as Entity from './Entity';\n\n/**\n * Individual query result entry.\n */\nexport type Entry<T> = {\n  id: string;\n\n  /**\n   * May not be present for remote results.\n   */\n  result?: T;\n\n  match?: {\n    // TODO(dmaretskyi): text positional info.\n\n    /**\n     * Higher means better match.\n     */\n    rank: number;\n  };\n\n  /**\n   * Query resolution metadata.\n   */\n  // TODO(dmaretskyi): Rename to meta?\n  resolution?: {\n    // TODO(dmaretskyi): Make this more generic.\n    source: 'remote' | 'local' | 'index';\n\n    /**\n     * Query resolution time in milliseconds.\n     */\n    time: number;\n  };\n};\n\n/**\n * Invidual query result entry for a database Entity.\n */\nexport type EntityEntry<T extends Entity.Unknown = Entity.Unknown> = Entry<T>;\n\nexport type RunOptions = {\n  timeout?: number;\n};\n\nexport type SubscriptionOptions = {\n  /**\n   * Fire the callback immediately.\n   */\n  fire?: boolean;\n};\n\n// TODO(burdon): Should T be constrained to Entity.Any?\nexport interface QueryResult<T> {\n  /**\n   * Currently available results along with their match metadata.\n   */\n  readonly entries: Entry<T>[];\n\n  /**\n   * Currently available results.\n   */\n  readonly results: T[];\n\n  /**\n   * Returns all known results.\n   */\n  run(opts?: RunOptions): Promise<T[]>;\n\n  /**\n   * Returns all known results along with their match metadata.\n   */\n  runEntries(opts?: RunOptions): Promise<Entry<T>[]>;\n\n  /**\n   * Returns currently available results synchronously.\n   */\n  runSync(): T[];\n\n  /**\n   * Returns currently available results synchronously along with their match metadata.\n   */\n  runSyncEntries(): Entry<T>[];\n\n  /**\n   * Returns first result.\n   */\n  first(opts?: RunOptions): Promise<T>;\n\n  /**\n   * Returns first result if there is one.\n   */\n  firstOrUndefined(opts?: RunOptions): Promise<T | undefined>;\n\n  /**\n   * Subscribes to changes in query results.\n   */\n  subscribe(callback?: (query: QueryResult<T>) => void, opts?: SubscriptionOptions): CleanupFn;\n}\n"],
-  "mappings": ";;;AAAA;",
+  "mappings": ";AAAA;",
   "names": []
 }

package/dist/lib/{node-esm/chunk-YOLH5KS4.mjs → neutral/chunk-RIMHNJ3E.mjs}

@@ -1,13 +1,14 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
   EntityKind,
   createAnnotationHelper
-} from "./chunk-XHJRMQZD.mjs";
+} from "./chunk-KB7RIVLK.mjs";
 
 // src/internal/types/typename.ts
 var ATTR_TYPE = "@type";
 var TypeId = Symbol.for("@dxos/echo/Type");
 var SchemaId = Symbol.for("@dxos/echo/Schema");
+var ATTR_PARENT = "@parent";
+var ParentId = Symbol.for("@dxos/echo/Parent");
 var getSchema = (obj) => {
   if (obj) {
     return obj[SchemaId];
@@ -232,11 +233,22 @@ var FormInputAnnotation = createAnnotationHelper(FormInputAnnotationId);
 var FieldLookupAnnotationId = Symbol.for("@dxos/schema/annotation/FieldLookup");
 var GeneratorAnnotationId = Symbol.for("@dxos/schema/annotation/Generator");
 var GeneratorAnnotation = createAnnotationHelper(GeneratorAnnotationId);
+var makeUserAnnotation = (props) => {
+  assertArgument(/[a-zA-Z0-9]+\.[a-zA-Z.]+\/[a-zA-Z/]+/.test(props.id), "id", "Annotation id must be in the FQN format (dxos.org/annotation/Example).");
+  const getFromAst = (ast) => SchemaAST.getAnnotation(PropertyMetaAnnotationId)(ast).pipe(Option.map((meta) => meta[props.id]), Option.map(Schema.decodeUnknownSync(props.schema)));
+  return {
+    get: (schema) => getFromAst(schema.ast),
+    getFromAst: (ast) => getFromAst(ast),
+    set: (value) => PropertyMeta(props.id, Schema.encodeSync(props.schema)(value))
+  };
+};
 
 export {
   ATTR_TYPE,
   TypeId,
   SchemaId,
+  ATTR_PARENT,
+  ParentId,
   getSchema,
   setSchema,
   FIELD_PATH_ANNOTATION,
@@ -278,6 +290,7 @@ export {
   FormInputAnnotation,
   FieldLookupAnnotationId,
   GeneratorAnnotationId,
-  GeneratorAnnotation
+  GeneratorAnnotation,
+  makeUserAnnotation
 };
-//# sourceMappingURL=chunk-YOLH5KS4.mjs.map
+//# sourceMappingURL=chunk-RIMHNJ3E.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/types/typename.ts", "../../../src/internal/annotations/annotations.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport type * as Schema from 'effect/Schema';\n\n/**\n * Property name for typename when object is serialized to JSON.\n */\nexport const ATTR_TYPE = '@type';\n\n/**\n * DXN to the object type.\n */\nexport const TypeId = Symbol.for('@dxos/echo/Type');\n\n/**\n * Reference to the object schema.\n */\nexport const SchemaId = Symbol.for('@dxos/echo/Schema');\n\n/**\n * Property name for parent when object is serialized to JSON.\n */\nexport const ATTR_PARENT = '@parent';\n\n/**\n * Reference to the object parent.\n */\nexport const ParentId = Symbol.for('@dxos/echo/Parent');\n\n/**\n * Returns the schema for the given object if one is defined.\n *\n * @internal (Use Obj.getSchema)\n */\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): For echo objects, this always returns the root schema.\nexport const getSchema = (obj: unknown | undefined): Schema.Schema.AnyNoContext | undefined => {\n  if (obj) {\n    return (obj as any)[SchemaId];\n  }\n};\n\n/**\n * @internal\n */\nexport const setSchema = (obj: any, schema: Schema.Schema.AnyNoContext): void => {\n  Object.defineProperty(obj, SchemaId, {\n    value: schema,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\n\nimport { raise } from '@dxos/debug';\nimport { type JsonPath, getField } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Primitive } from '@dxos/util';\n\nimport { type AnyProperties, EntityKind, TypeId, getSchema } from '../types';\n\nimport { type AnnotationHelper, createAnnotationHelper } from './util';\n\n/**\n * @internal\n */\nexport const FIELD_PATH_ANNOTATION = 'path';\n\n/**\n * Sets the path for the field.\n * @param path Data source path in the json path format. This is the field path in the source object.\n */\n// TODO(burdon): Field, vs. path vs. property.\nexport const FieldPath = (path: string) => PropertyMeta(FIELD_PATH_ANNOTATION, path);\n\n//\n// Type\n//\n\n/**\n * ECHO identifier (for a stored schema).\n * Must be a `dxn:echo:` URI.\n */\nexport const TypeIdentifierAnnotationId = Symbol.for('@dxos/schema/annotation/TypeIdentifier');\n\nexport const getTypeIdentifierAnnotation = (schema: Schema.Schema.All) =>\n  Function.flow(\n    SchemaAST.getAnnotation<string>(TypeIdentifierAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n\n/**\n * @returns DXN of the schema.\n *\n * For non-stored schema returns `dxn:type:`.\n * For stored schema returns `dxn:echo:`.\n */\nexport const getSchemaDXN = (schema: Schema.Schema.All): DXN | undefined => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');\n  const id = getTypeIdentifierAnnotation(schema);\n  if (id) {\n    return DXN.parse(id);\n  }\n\n  // TODO(dmaretskyi): Add support for dynamic schema.\n  const objectAnnotation = getTypeAnnotation(schema);\n  if (!objectAnnotation) {\n    return undefined;\n  }\n\n  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);\n};\n\n/**\n * @param input schema or a typename string.\n * @return type DXN.\n */\nexport const getTypeDXNFromSpecifier = (input: Schema.Schema.All | string): DXN => {\n  if (Schema.isSchema(input)) {\n    return getSchemaDXN(input) ?? raise(new TypeError('Schema has no DXN'));\n  } else {\n    assertArgument(typeof input === 'string', 'input');\n    assertArgument(!input.startsWith('dxn:'), 'input');\n    return DXN.fromTypename(input);\n  }\n};\n\n//\n// TypeAnnotation\n//\n\n/**\n * Fully qualified globally unique typename.\n * Example: `dxos.org/type/Message`\n */\n// TODO(burdon): Reconcile with short DXN format.\n// TODO(burdon): Change \"/type\" => \"/schema\" throughout.\nexport const TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\\w+\\.[a-zA-Z]\\w{1,}\\/[\\w/_-]+$/)).annotations(\n  {\n    description: 'Fully qualified globally unique typename',\n    example: 'dxos.org/type/Message',\n  },\n);\n\n/**\n * Semantic version format: `major.minor.patch`\n * Example: `1.0.0`\n */\nexport const VersionSchema = Schema.String.pipe(Schema.pattern(/^\\d+.\\d+.\\d+$/)).annotations({\n  description: 'Semantic version format: `major.minor.patch`',\n  example: '1.0.0',\n});\n\nexport const TypeMeta = Schema.Struct({\n  typename: TypenameSchema,\n  version: VersionSchema,\n});\n\nexport interface TypeMeta extends Schema.Schema.Type<typeof TypeMeta> {}\n\n/**\n * Entity type.\n */\nexport const TypeAnnotationId = Symbol.for('@dxos/schema/annotation/Type');\n\n/**\n * Payload stored under {@link TypeAnnotationId}.\n */\nexport const TypeAnnotation = Schema.extend(\n  TypeMeta,\n  Schema.Struct({\n    kind: Schema.Enums(EntityKind),\n\n    /**\n     * If this is a relation, the schema of the source object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    sourceSchema: Schema.optional(DXN.Schema),\n\n    /**\n     * If this is a relation, the schema of the target object.\n     * Must be present if entity kind is {@link EntityKind.Relation}.\n     */\n    targetSchema: Schema.optional(DXN.Schema),\n  }),\n);\n\nexport interface TypeAnnotation extends Schema.Schema.Type<typeof TypeAnnotation> {}\n\n/**\n * @returns {@link TypeAnnotation} from a schema.\n * Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.\n */\nexport const getTypeAnnotation = (schema: Schema.Schema.All): TypeAnnotation | undefined => {\n  assertArgument(schema != null && schema.ast != null, 'schema', 'invalid schema');\n  return Function.flow(\n    SchemaAST.getAnnotation<TypeAnnotation>(TypeAnnotationId),\n    Option.getOrElse(() => undefined),\n  )(schema.ast);\n};\n\n/**\n * @returns {@link EntityKind} from a schema.\n */\nexport const getEntityKind = (schema: Schema.Schema.All): EntityKind | undefined => getTypeAnnotation(schema)?.kind;\n\n/**\n * @internal\n * @returns Schema typename (without dxn: prefix or version number).\n */\nexport const getSchemaTypename = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.typename;\n\n/**\n * @internal\n * @returns Schema version in semver format.\n */\nexport const getSchemaVersion = (schema: Schema.Schema.All): string | undefined => getTypeAnnotation(schema)?.version;\n\n/**\n * Gets the typename of the object without the version.\n * Returns only the name portion, not the DXN.\n * @example \"example.org/type/Contact\"\n *\n * @internal (use Obj.getTypename)\n */\nexport const getTypename = (obj: AnyProperties): string | undefined => {\n  const schema = getSchema(obj);\n  if (schema != null) {\n    // Try to extract typename from DXN.\n    return getSchemaTypename(schema);\n  } else {\n    const type = getTypeDXN(obj);\n    return type?.asTypeDXN()?.type;\n  }\n};\n\n/**\n * @internal (use Type.setTypename)\n */\n// TODO(dmaretskyi): Rename setTypeDXN.\nexport const setTypename = (obj: any, typename: DXN): void => {\n  invariant(typename instanceof DXN, 'Invalid type.');\n  Object.defineProperty(obj, TypeId, {\n    value: typename,\n    writable: false,\n    enumerable: false,\n    configurable: false,\n  });\n};\n\n/**\n * @returns Object type as {@link DXN}.\n * @returns undefined if the object doesn't have a type.\n * @example `dxn:example.com/type/Person:1.0.0`\n *\n * @internal (use Obj.getTypeDXN)\n */\n// TODO(burdon): Narrow type.\nexport const getTypeDXN = (obj: AnyProperties): DXN | undefined => {\n  if (!obj) {\n    return undefined;\n  }\n\n  const type = (obj as any)[TypeId];\n  if (!type) {\n    return undefined;\n  }\n\n  invariant(type instanceof DXN, 'Invalid object.');\n  return type;\n};\n\n/**\n * Checks if the object is an instance of the schema.\n * Only typename is compared, the schema version is ignored.\n *\n * The following cases are considered to mean that the object is an instance of the schema:\n *  - Object was created with this exact schema.\n *  - Object was created with a different version of this schema.\n *  - Object was created with a different schema (maybe dynamic) that has the same typename.\n */\n// TODO(burdon): Can we use `Schema.is`?\nexport const isInstanceOf = <Schema extends Schema.Schema.AnyNoContext>(\n  schema: Schema,\n  object: any,\n): object is Schema.Schema.Type<Schema> => {\n  if (object == null) {\n    return false;\n  }\n\n  const schemaDXN = getSchemaDXN(schema);\n  if (!schemaDXN) {\n    throw new Error('Schema must have an object annotation.');\n  }\n\n  const type = getTypeDXN(object);\n  if (type && DXN.equals(type, schemaDXN)) {\n    return true;\n  }\n\n  const typename = getTypename(object);\n  if (!typename) {\n    return false;\n  }\n\n  const typeDXN = schemaDXN.asTypeDXN();\n  if (!typeDXN) {\n    return false;\n  }\n\n  return typeDXN.type === typename;\n};\n\n//\n// PropertyMeta\n//\n\n/**\n * PropertyMeta (metadata for dynamic schema properties).\n * For user-defined annotations.\n */\nexport const PropertyMetaAnnotationId = Symbol.for('@dxos/schema/annotation/PropertyMeta');\n\nexport type PropertyMetaValue = Primitive | Record<string, Primitive> | Primitive[];\n\nexport type PropertyMetaAnnotation = {\n  [name: string]: PropertyMetaValue;\n};\n\n// TODO(wittjosiah): Align with other annotations.\n// TODO(wittjosiah): Why is this separate from FormatAnnotation?\nexport const PropertyMeta = (name: string, value: PropertyMetaValue) => {\n  return <A, I, R>(self: Schema.Schema<A, I, R>): Schema.Schema<A, I, R> => {\n    const existingMeta = self.ast.annotations[PropertyMetaAnnotationId] as PropertyMetaAnnotation;\n    return self.annotations({\n      [PropertyMetaAnnotationId]: {\n        ...existingMeta,\n        [name]: value,\n      },\n    });\n  };\n};\n\nexport const getPropertyMetaAnnotation = <T>(prop: SchemaAST.PropertySignature, name: string) =>\n  Function.pipe(\n    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(prop.type),\n    Option.map((meta) => meta[name] as T),\n    Option.getOrElse(() => undefined),\n  );\n\n//\n// Reference\n//\n\n/**\n * Schema reference.\n */\nexport const ReferenceAnnotationId = Symbol.for('@dxos/schema/annotation/Reference');\nexport type ReferenceAnnotationValue = TypeAnnotation;\nexport const ReferenceAnnotation = createAnnotationHelper<ReferenceAnnotationValue>(ReferenceAnnotationId);\n\n/**\n * SchemaMeta.\n */\nexport const SchemaMetaSymbol = Symbol.for('@dxos/schema/SchemaMeta');\nexport type SchemaMeta = TypeMeta & { id: string };\n\n/**\n * Identifies a schema as a schema for a hidden system type.\n */\nexport const SystemTypeAnnotationId = Symbol.for('@dxos/schema/annotation/SystemType');\nexport const SystemTypeAnnotation = createAnnotationHelper<boolean>(SystemTypeAnnotationId);\n\n/**\n * Identifies label property or JSON path expression.\n * Either a string or an array of strings representing field accessors each matched in priority order.\n */\nexport const LabelAnnotationId = Symbol.for('@dxos/schema/annotation/Label');\nexport const LabelAnnotation = createAnnotationHelper<string[]>(LabelAnnotationId);\n\n/**\n * Returns the label for a given object based on {@link LabelAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\n// TODO(burdon): Convert to JsonPath?\nexport const getLabelWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n): string | undefined => {\n  const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => ['name']));\n  for (const accessor of annotation) {\n    assertArgument(\n      typeof accessor === 'string',\n      'accessor',\n      'Label annotation must be a string or an array of strings',\n    );\n    const value = getField(object, accessor as JsonPath);\n    switch (typeof value) {\n      case 'string':\n      case 'number':\n      case 'boolean':\n      case 'bigint':\n      case 'symbol':\n        return value.toString();\n      case 'undefined':\n      case 'object':\n      case 'function':\n        continue;\n    }\n  }\n\n  return undefined;\n};\n\n/**\n * Sets the label for a given object based on {@link LabelAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\nexport const setLabelWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n  label: string,\n) => {\n  const annotation = LabelAnnotation.get(schema).pipe(\n    Option.map((field) => field[0]),\n    Option.getOrElse(() => 'name'),\n  );\n  object[annotation] = label;\n};\n\n/**\n * Identifies description property or JSON path expression.\n * A string representing field accessor.\n */\nexport const DescriptionAnnotationId = Symbol.for('@dxos/schema/annotation/Description');\nexport const DescriptionAnnotation = createAnnotationHelper<string>(DescriptionAnnotationId);\n\n/**\n * Returns the description for a given object based on {@link DescriptionAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\n// TODO(burdon): Convert to JsonPath?\nexport const getDescriptionWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n): string | undefined => {\n  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  assertArgument(typeof accessor === 'string', 'accessor', 'Description annotation must be a string');\n  const value = getField(object, accessor as JsonPath);\n  switch (typeof value) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'bigint':\n    case 'symbol':\n      return value.toString();\n    case 'undefined':\n    case 'object':\n    case 'function':\n    default:\n      return undefined;\n  }\n};\n\n/**\n * Sets the description for a given object based on {@link DescriptionAnnotationId}.\n * Lower-level version that requires explicit schema parameter.\n */\nexport const setDescriptionWithSchema = <S extends Schema.Schema.Any>(\n  schema: S,\n  object: Schema.Schema.Type<S>,\n  description: string,\n) => {\n  const accessor = DescriptionAnnotation.get(schema).pipe(Option.getOrElse(() => 'description'));\n  object[accessor] = description;\n};\n\n/**\n * Identifies if a property should be included in a form or not.\n * By default, all properties are included in forms, so this is opt-out.\n */\n// TODO(burdon): UI concern.\nexport const FormInputAnnotationId = Symbol.for('@dxos/schema/annotation/FormInput');\nexport const FormInputAnnotation = createAnnotationHelper<boolean>(FormInputAnnotationId);\n\n/**\n * Default field to be used on referenced schema to lookup the value.\n */\nexport const FieldLookupAnnotationId = Symbol.for('@dxos/schema/annotation/FieldLookup');\n\n/**\n * Generate test data.\n */\nexport const GeneratorAnnotationId = Symbol.for('@dxos/schema/annotation/Generator');\n\nexport type GeneratorAnnotationValue =\n  | string\n  | {\n      generator: string;\n      args?: any[];\n      probability?: number;\n    };\n\nexport const GeneratorAnnotation = createAnnotationHelper<GeneratorAnnotationValue>(GeneratorAnnotationId);\n\ninterface MakeAnnoationsProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n// TODO(wittjosiah): Comment.\nexport const makeUserAnnotation = <T>(props: MakeAnnoationsProps<T>): AnnotationHelper<T> => {\n  assertArgument(\n    /[a-zA-Z0-9]+\\.[a-zA-Z.]+\\/[a-zA-Z/]+/.test(props.id),\n    'id',\n    'Annotation id must be in the FQN format (dxos.org/annotation/Example).',\n  );\n\n  const getFromAst = (ast: SchemaAST.AST) =>\n    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(ast).pipe(\n      Option.map((meta) => meta[props.id] as unknown),\n      Option.map(Schema.decodeUnknownSync(props.schema)),\n    );\n\n  return {\n    get: (schema) => getFromAst(schema.ast),\n    getFromAst: (ast) => getFromAst(ast),\n    set: (value) =>\n      PropertyMeta(props.id, Schema.encodeSync(props.schema)(value)) as <S extends Schema.Schema.Any>(schema: S) => S,\n  };\n};\n"],
+  "mappings": "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",
+  "names": ["ATTR_TYPE", "TypeId", "Symbol", "for", "SchemaId", "ATTR_PARENT", "ParentId", "getSchema", "obj", "setSchema", "schema", "Object", "defineProperty", "value", "writable", "enumerable", "configurable", "Function", "Option", "Schema", "SchemaAST", "raise", "getField", "assertArgument", "invariant", "DXN", "FIELD_PATH_ANNOTATION", "FieldPath", "path", "PropertyMeta", "TypeIdentifierAnnotationId", "Symbol", "for", "getTypeIdentifierAnnotation", "schema", "flow", "getAnnotation", "getOrElse", "undefined", "ast", "getSchemaDXN", "assertArgument", "isSchema", "id", "DXN", "parse", "objectAnnotation", "getTypeAnnotation", "fromTypenameAndVersion", "typename", "version", "getTypeDXNFromSpecifier", "input", "raise", "TypeError", "startsWith", "fromTypename", "TypenameSchema", "String", "pipe", "pattern", "annotations", "description", "example", "VersionSchema", "TypeMeta", "Struct", "TypeAnnotationId", "TypeAnnotation", "extend", "kind", "Enums", "EntityKind", "sourceSchema", "optional", "Schema", "targetSchema", "getEntityKind", "getSchemaTypename", "getSchemaVersion", "getTypename", "obj", "getSchema", "type", "getTypeDXN", "asTypeDXN", "setTypename", "invariant", "Object", "defineProperty", "TypeId", "value", "writable", "enumerable", "configurable", "isInstanceOf", "object", "schemaDXN", "Error", "equals", "typeDXN", "PropertyMetaAnnotationId", "name", "self", "existingMeta", "getPropertyMetaAnnotation", "prop", "map", "meta", "ReferenceAnnotationId", "ReferenceAnnotation", "createAnnotationHelper", "SchemaMetaSymbol", "SystemTypeAnnotationId", "SystemTypeAnnotation", "LabelAnnotationId", "LabelAnnotation", "getLabelWithSchema", "annotation", "get", "accessor", "getField", "toString", "setLabelWithSchema", "label", "field", "DescriptionAnnotationId", "DescriptionAnnotation", "getDescriptionWithSchema", "setDescriptionWithSchema", "FormInputAnnotationId", "FormInputAnnotation", "FieldLookupAnnotationId", "GeneratorAnnotationId", "GeneratorAnnotation", "makeUserAnnotation", "props", "test", "getFromAst", "decodeUnknownSync", "set", "encodeSync"]
+}

package/dist/lib/{browser/chunk-JMKVF2YQ.mjs → neutral/chunk-ROKO4RKJ.mjs}

@@ -1,7 +1,6 @@
-import "@dxos/node-std/globals";
 import {
   __export
-} from "./chunk-CGS2ULMK.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/Order.ts
 var Order_exports = {};
@@ -40,4 +39,4 @@ export {
   rank,
   Order_exports
 };
-//# sourceMappingURL=chunk-JMKVF2YQ.mjs.map
+//# sourceMappingURL=chunk-ROKO4RKJ.mjs.map

package/dist/lib/{node-esm/chunk-K37NA7PO.mjs.map → neutral/chunk-ROKO4RKJ.mjs.map}

@@ -2,6 +2,6 @@
   "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;",
+  "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/{browser/chunk-KQQGVHFN.mjs → neutral/chunk-SHLKRGRB.mjs}

@@ -1,4 +1,3 @@
-import "@dxos/node-std/globals";
 import {
   EchoObjectSchema,
   EchoRelationSchema,
@@ -8,22 +7,22 @@ import {
   isMutable,
   toEffectSchema,
   toJsonSchema
-} from "./chunk-BJPE6CIC.mjs";
+} from "./chunk-ZUG3PNXU.mjs";
 import {
   getSchemaDXN,
   getSchemaTypename,
   getSchemaVersion,
   getTypeAnnotation
-} from "./chunk-RK4Z4JUZ.mjs";
+} from "./chunk-RIMHNJ3E.mjs";
 import {
   ANY_OBJECT_TYPENAME,
   ANY_OBJECT_VERSION,
   EntityKind,
   SchemaKindId
-} from "./chunk-YKTSSMDS.mjs";
+} from "./chunk-KB7RIVLK.mjs";
 import {
   __export
-} from "./chunk-CGS2ULMK.mjs";
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/Type.ts
 var Type_exports = {};
@@ -140,4 +139,4 @@ export {
   Entity,
   Type_exports
 };
-//# sourceMappingURL=chunk-KQQGVHFN.mjs.map
+//# sourceMappingURL=chunk-SHLKRGRB.mjs.map