@dxos/echo 0.8.4-main.74a063c4e0 → 0.8.4-main.765dc60934

package/dist/lib/neutral/{chunk-XZJUNTML.mjs → chunk-APJKDGFL.mjs}

@@ -1,12 +1,13 @@
 import {
   isRef
-} from "./chunk-46QNGNTY.mjs";
+} from "./chunk-N7VOEPSV.mjs";
 import {
+  getDXN,
   prettyFilter
-} from "./chunk-WMFVS4KR.mjs";
+} from "./chunk-G54OX4IX.mjs";
 import {
   getTypeDXNFromSpecifier
-} from "./chunk-6URFBQJH.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -16,6 +17,7 @@ var Filter_exports = {};
 __export(Filter_exports, {
   and: () => and,
   between: () => between,
+  childOf: () => childOf,
   contains: () => contains,
   created: () => created,
   eq: () => eq,
@@ -27,6 +29,7 @@ __export(Filter_exports, {
   id: () => id,
   in: () => in$,
   is: () => is,
+  key: () => key,
   lt: () => lt,
   lte: () => lte,
   neq: () => neq,
@@ -130,6 +133,15 @@ var tag = (tag2) => {
     tag: tag2
   });
 };
+var key = (key2, options) => {
+  return new FilterClass({
+    type: "object",
+    typename: null,
+    props: {},
+    metaKey: key2,
+    metaVersion: options?.version
+  });
+};
 var props = (props2) => {
   return new FilterClass({
     type: "object",
@@ -243,6 +255,22 @@ var _timeRangeFilter = (field, range) => {
 };
 var updated = (range) => _timeRangeFilter("updatedAt", range);
 var created = (range) => _timeRangeFilter("createdAt", range);
+var childOf = (parents, options) => {
+  const items = Array.isArray(parents) ? parents : [
+    parents
+  ];
+  const dxns = items.map((item) => {
+    if (isRef(item)) {
+      return item.dxn.toString();
+    }
+    return getDXN(item).toString();
+  });
+  return new FilterClass({
+    type: "child-of",
+    parents: dxns,
+    transitive: options?.transitive ?? true
+  });
+};
 var not = (filter) => {
   return new FilterClass({
     type: "not",
@@ -287,8 +315,8 @@ var processPredicate = (predicate) => {
       throw new Error("Array predicates are not yet supported.");
     }),
     Match.when((predicate2) => !isRef(predicate2) && typeof predicate2 === "object" && predicate2 !== null, (predicate2) => {
-      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key, value2]) => [
-        key,
+      const nestedProps = Object.fromEntries(Object.entries(predicate2).map(([key2, value2]) => [
+        key2,
         processPredicate(value2)
       ]));
       return {
@@ -312,6 +340,7 @@ export {
   typename,
   typeDXN,
   tag,
+  key,
   props,
   text,
   foreignKeys,
@@ -326,10 +355,11 @@ export {
   between,
   updated,
   created,
+  childOf,
   not,
   and,
   or,
   pretty,
   Filter_exports
 };
-//# sourceMappingURL=chunk-XZJUNTML.mjs.map
+//# sourceMappingURL=chunk-APJKDGFL.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Filter.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\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 * as internal from './internal';\nimport type * as Obj from './Obj';\nimport * as Ref from './Ref';\n\nexport interface Filter<T> {\n  // TODO(dmaretskyi): See new effect-schema approach to variance.\n  '~Filter': { value: Types.Covariant<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  if (Schema.isSchema(schema) && SchemaAST.isUnion(schema.ast)) {\n    const typenames = schema.ast.types.map((type) => internal.getTypeDXNFromSpecifier(Schema.make(type)));\n    return new FilterClass({\n      type: 'or',\n      filters: typenames.map((typename) => ({\n        type: 'object',\n        typename: typename.toString(),\n        props: {},\n      })),\n    });\n  }\n\n  const dxn = internal.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 * Options for {@link key} filter.\n */\nexport type KeyFilterOptions = {\n  /**\n   * Optional semver range expression (e.g. `^1.2.3`, `~2.0.0`, `>=1.0.0 <2.0.0`).\n   * Matches the object's meta `version` field against the range.\n   * If omitted, matches any version (including objects with no version).\n   */\n  version?: string;\n};\n\n/**\n * Filter by registry key stored in object meta.\n *\n * @example\n * ```ts\n * Filter.key('org.example.type.foo');\n * Filter.key('org.example.type.foo', { version: '^1.2.3' });\n * ```\n */\nexport const key = (key: string, options?: KeyFilterOptions): Any => {\n  return new FilterClass({\n    type: 'object',\n    typename: null,\n    props: {},\n    metaKey: key,\n    metaVersion: options?.version,\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 = internal.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> => {\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<T> => {\n  return new FilterClass({\n    type: 'range',\n    from,\n    to,\n  });\n};\n\ntype TimeRange = { after?: Date | number; before?: Date | number };\n\nconst _toUnixMs = (date: Date | number): number => (typeof date === 'number' ? date : date.getTime());\n\nconst _timeRangeFilter = (field: 'updatedAt' | 'createdAt', range: TimeRange): Any => {\n  const filters: Any[] = [];\n  if (range.after != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'gte', value: _toUnixMs(range.after) }));\n  }\n  if (range.before != null) {\n    filters.push(new FilterClass({ type: 'timestamp', field, operator: 'lte', value: _toUnixMs(range.before) }));\n  }\n  if (filters.length === 0) {\n    return everything();\n  }\n  return filters.length === 1 ? filters[0] : and(...filters);\n};\n\n/**\n * Filter objects by updatedAt timestamp.\n */\nexport const updated = (range: TimeRange): Any => _timeRangeFilter('updatedAt', range);\n\n/**\n * Filter objects by createdAt timestamp.\n */\nexport const created = (range: TimeRange): Any => _timeRangeFilter('createdAt', range);\n\nexport type ChildOfOptions = {\n  /** Whether to match transitively (grandchildren, etc.). Defaults to true. */\n  transitive?: boolean;\n};\n\n/**\n * Filter objects that are children of the specified parent(s).\n * Accepts ECHO objects, Refs, or arrays of either.\n * Refs are resolved to DXNs without loading; objects use {@link Obj.getDXN}.\n * With transitive=true (default), also matches grandchildren and beyond.\n */\nexport const childOf = (\n  parents: Obj.Unknown | Ref.Unknown | readonly (Obj.Unknown | Ref.Unknown)[],\n  options?: ChildOfOptions,\n): Any => {\n  const items = Array.isArray(parents) ? parents : [parents];\n  const dxns = items.map((item) => {\n    if (Ref.isRef(item)) {\n      return item.dxn.toString();\n    }\n    return internal.getDXN(item).toString();\n  });\n  return new FilterClass({\n    type: 'child-of',\n    parents: dxns,\n    transitive: options?.transitive ?? true,\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\n/**\n * Returns a human-readable string representation of a Filter AST.\n */\nexport const pretty = (filter: Any): string => internal.prettyFilter(filter.ast);\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,YAAYA,WAAW;AACvB,YAAYC,YAAY;AACxB,YAAYC,eAAe;AAI3B,SAASC,sBAAsB;AAC/B,SAASC,KAAKC,gBAAgB;AAsB9B,IAAMC,cAAN,MAAMA,aAAAA;;EACJ,OAAe,aAA6B,CAAC;EAE7C,YAA4BC,KAAsB;SAAtBA,MAAAA;EAAuB;EAEnD,YAAYD,aAAYE;AAC1B;AAEO,IAAMC,KAAK,CAACC,WAAAA;AACjB,SAAO,OAAOA,WAAU,YAAYA,WAAU,QAAQ,aAAaA;AACrE;AAGO,IAAMC,UAAU,CAACJ,QAAAA;AACtB,SAAO,IAAID,YAAYC,GAAAA;AACzB;AAMO,IAAMK,aAAa,MAAA;AACxB,SAAO,IAAIN,YAAY;IACrBO,MAAM;IACNC,UAAU;IACVC,OAAO,CAAC;EACV,CAAA;AACF;AAKO,IAAMC,UAAU,MAAA;AACrB,SAAO,IAAIV,YAAY;IACrBO,MAAM;IACNI,QAAQ;MACNJ,MAAM;MACNC,UAAU;MACVC,OAAO,CAAC;IACV;EACF,CAAA;AACF;AAKO,IAAMG,KAAK,IAAIC,QAAAA;AACpBC,iBACED,IAAIE,MAAM,CAACH,QAAOI,SAASC,QAAQL,GAAAA,CAAAA,GACnC,OACA,mBAAA;AAGF,MAAIC,IAAIK,WAAW,GAAG;AACpB,WAAOR,QAAAA;EACT;AAEA,SAAO,IAAIV,YAAY;IACrBO,MAAM;IACNC,UAAU;IACVI,IAAIC;IACJJ,OAAO,CAAC;EACV,CAAA;AACF;AAKO,IAAMF,OAAO,CAClBY,QACAV,WAAAA;AAEA,MAAWW,gBAASD,MAAAA,KAAqBE,kBAAQF,OAAOlB,GAAG,GAAG;AAC5D,UAAMqB,YAAYH,OAAOlB,IAAIsB,MAAMC,IAAI,CAACjB,UAAkBkB,wBAA+BC,YAAKnB,KAAAA,CAAAA,CAAAA;AAC9F,WAAO,IAAIP,YAAY;MACrBO,MAAM;MACNoB,SAASL,UAAUE,IAAI,CAAChB,eAAc;QACpCD,MAAM;QACNC,UAAUA,UAASoB,SAAQ;QAC3BnB,OAAO,CAAC;MACV,EAAA;IACF,CAAA;EACF;AAEA,QAAMoB,MAAeJ,wBAAwBN,MAAAA;AAC7C,SAAO,IAAInB,YAAY;IACrBO,MAAM;IACNC,UAAUqB,IAAID,SAAQ;IACtB,GAAGE,iBAAiBrB,UAAS,CAAC,CAAA;EAChC,CAAA;AACF;AAKO,IAAMD,WAAW,CAACA,cAAAA;AACvBM,iBAAe,CAACN,UAASuB,WAAW,MAAA,GAAS,YAAY,+BAAA;AACzD,SAAO,IAAI/B,YAAY;IACrBO,MAAM;IACNC,UAAUwB,IAAIC,aAAazB,SAAAA,EAAUoB,SAAQ;IAC7CnB,OAAO,CAAC;EACV,CAAA;AACF;AAKO,IAAMyB,UAAU,CAACL,QAAAA;AACtB,SAAO,IAAI7B,YAAY;IACrBO,MAAM;IACNC,UAAUqB,IAAID,SAAQ;IACtBnB,OAAO,CAAC;EACV,CAAA;AACF;AAKO,IAAM0B,MAAM,CAACA,SAAAA;AAClB,SAAO,IAAInC,YAAY;IACrBO,MAAM;IACN4B,KAAAA;EACF,CAAA;AACF;AAuBO,IAAMC,MAAM,CAACA,MAAaC,YAAAA;AAC/B,SAAO,IAAIrC,YAAY;IACrBO,MAAM;IACNC,UAAU;IACVC,OAAO,CAAC;IACR6B,SAASF;IACTG,aAAaF,SAASG;EACxB,CAAA;AACF;AAKO,IAAM/B,QAAQ,CAAIA,WAAAA;AACvB,SAAO,IAAIT,YAAY;IACrBO,MAAM;IACNC,UAAU;IACV,GAAGsB,iBAAiBrB,MAAAA;EACtB,CAAA;AACF;AAUO,IAAMgC,OAAO,CAElBA,OACAJ,YAAAA;AAEA,SAAO,IAAIrC,YAAY;IACrBO,MAAM;IACNkC,MAAAA;IACAC,YAAYL,SAAS9B;EACvB,CAAA;AACF;AAKO,IAAMoC,cAAc,CACzBxB,QACAyB,SAAAA;AAEA,QAAMf,MAAeJ,wBAAwBN,MAAAA;AAC7C,SAAO,IAAInB,YAAY;IACrBO,MAAM;IACNC,UAAUqB,IAAID,SAAQ;IACtBnB,OAAO,CAAC;IACRkC,aAAaC;EACf,CAAA;AACF;AAKO,IAAMC,KAAK,CAAIzC,WAAAA;AACpB,MAAI,CAAK0C,MAAM1C,MAAAA,KAAU,OAAOA,WAAU,YAAYA,WAAU,MAAM;AACpE,UAAM,IAAI2C,UAAU,4CAAA;EACtB;AAEA,SAAO,IAAI/C,YAAY;IACrBO,MAAM;IACNyC,UAAU;IACV5C,OAAW0C,MAAM1C,MAAAA,IAASA,OAAM6C,SAAQ,EAAGC,OAAM,IAAK9C;EACxD,CAAA;AACF;AAKO,IAAM+C,MAAM,CAAI/C,WAAAA;AACrB,SAAO,IAAIJ,YAAY;IACrBO,MAAM;IACNyC,UAAU;IACV5C,OAAAA;EACF,CAAA;AACF;AAKO,IAAMgD,KAAK,CAAIhD,WAAAA;AACpB,SAAO,IAAIJ,YAAY;IACrBO,MAAM;IACNyC,UAAU;IACV5C,OAAAA;EACF,CAAA;AACF;AAKO,IAAMiD,MAAM,CAAIjD,WAAAA;AACrB,SAAO,IAAIJ,YAAY;IACrBO,MAAM;IACNyC,UAAU;IACV5C,OAAAA;EACF,CAAA;AACF;AAKO,IAAMkD,KAAK,CAAIlD,WAAAA;AACpB,SAAO,IAAIJ,YAAY;IACrBO,MAAM;IACNyC,UAAU;IACV5C,OAAAA;EACF,CAAA;AACF;AAKO,IAAMmD,MAAM,CAAInD,WAAAA;AACrB,SAAO,IAAIJ,YAAY;IACrBO,MAAM;IACNyC,UAAU;IACV5C,OAAAA;EACF,CAAA;AACF;AAMA,IAAMoD,MAAM,IAAOC,WAAAA;AACjB,SAAO,IAAIzD,YAAY;IACrBO,MAAM;IACNkD;EACF,CAAA;AACF;AAOO,IAAMC,WAAW,CAAIC,WAAAA;AAC1B,SAAO,IAAIC,YAAY;IACrBC,MAAM;IACNF,OAAAA;EACF,CAAA;AACF;AAOO,IAAMG,UAAU,CAAIC,MAASC,OAAAA;AAClC,SAAO,IAAIJ,YAAY;IACrBC,MAAM;IACNE;IACAC;EACF,CAAA;AACF;AAIA,IAAMC,YAAY,CAACC,SAAiC,OAAOA,SAAS,WAAWA,OAAOA,KAAKC,QAAO;AAElG,IAAMC,mBAAmB,CAACC,OAAkCC,UAAAA;AAC1D,QAAMC,UAAiB,CAAA;AACvB,MAAID,MAAME,SAAS,MAAM;AACvBD,YAAQE,KAAK,IAAIb,YAAY;MAAEC,MAAM;MAAaQ;MAAOK,UAAU;MAAOf,OAAOM,UAAUK,MAAME,KAAK;IAAE,CAAA,CAAA;EAC1G;AACA,MAAIF,MAAMK,UAAU,MAAM;AACxBJ,YAAQE,KAAK,IAAIb,YAAY;MAAEC,MAAM;MAAaQ;MAAOK,UAAU;MAAOf,OAAOM,UAAUK,MAAMK,MAAM;IAAE,CAAA,CAAA;EAC3G;AACA,MAAIJ,QAAQK,WAAW,GAAG;AACxB,WAAOC,WAAAA;EACT;AACA,SAAON,QAAQK,WAAW,IAAIL,QAAQ,CAAA,IAAKO,IAAAA,GAAOP,OAAAA;AACpD;AAKO,IAAMQ,UAAU,CAACT,UAA0BF,iBAAiB,aAAaE,KAAAA;AAKzE,IAAMU,UAAU,CAACV,UAA0BF,iBAAiB,aAAaE,KAAAA;AAazE,IAAMW,UAAU,CACrBC,SACAC,YAAAA;AAEA,QAAMC,QAAQC,MAAMC,QAAQJ,OAAAA,IAAWA,UAAU;IAACA;;AAClD,QAAMK,OAAOH,MAAMI,IAAI,CAACC,SAAAA;AACtB,QAAQC,MAAMD,IAAAA,GAAO;AACnB,aAAOA,KAAKE,IAAIC,SAAQ;IAC1B;AACA,WAAgBC,OAAOJ,IAAAA,EAAMG,SAAQ;EACvC,CAAA;AACA,SAAO,IAAIhC,YAAY;IACrBC,MAAM;IACNqB,SAASK;IACTO,YAAYX,SAASW,cAAc;EACrC,CAAA;AACF;AAKO,IAAMC,MAAM,CAAgBC,WAAAA;AACjC,SAAO,IAAIpC,YAAY;IACrBC,MAAM;IACNmC,QAAQA,OAAOC;EACjB,CAAA;AACF;AAKO,IAAMnB,MAAM,IAAoCP,YAAAA;AACrD,SAAO,IAAIX,YAAY;IACrBC,MAAM;IACNU,SAASA,QAAQiB,IAAI,CAACU,MAAMA,EAAED,GAAG;EACnC,CAAA;AACF;AAKO,IAAME,KAAK,IAAoC5B,YAAAA;AACpD,SAAO,IAAIX,YAAY;IACrBC,MAAM;IACNU,SAASA,QAAQiB,IAAI,CAACU,MAAMA,EAAED,GAAG;EACnC,CAAA;AACF;AAIA,IAAMG,mBAAmB,CAACC,eAAAA;AACxB,MAAIC;AACJ,MAAI,QAAQD,YAAY;AACtBE,mBACE,OAAOF,WAAWG,OAAO,YAAYnB,MAAMC,QAAQe,WAAWG,EAAE,GAChE,iBACA,mBAAA;AAEFF,eAAW,OAAOD,WAAWG,OAAO,WAAW;MAACH,WAAWG;QAAMH,WAAWG;AAC5EC,IAAOpB,aAAMqB,QAAAA,EAAUC,KAAYC,mBAAY,EAAEN,QAAAA;EACnD;AAEA,SAAO;IACLE,IAAIF;IACJO,OAAOC,OAAOC,YACZD,OAAOE,QAAQX,UAAAA,EACZL,OAAO,CAAC,CAACiB,MAAMC,MAAAA,MAAYD,SAAS,IAAA,EACpCzB,IAAI,CAAC,CAACyB,MAAME,SAAAA,MAAe;MAACF;MAAMG,iBAAiBD,SAAAA;KAAW,CAAA;EAErE;AACF;AAEA,IAAMC,mBAAmB,CAACD,cAAAA;AACxB,SAAaxD,YAAMwD,SAAAA,EAAWR;IACtBU,qBAAc;IACdC,WAAKC,IAAI,CAACJ,eAAcA,WAAUlB,GAAG;;IAErCqB,WAAKjC,MAAMC,SAAS,CAACkC,eAAAA;AACzB,YAAM,IAAIC,MAAM,yCAAA;IAClB,CAAA;IACMH,WACJ,CAACH,eAAmB,CAAKzB,MAAMyB,UAAAA,KAAc,OAAOA,eAAc,YAAYA,eAAc,MAC5F,CAACA,eAAAA;AACC,YAAMO,cAAcZ,OAAOC,YACzBD,OAAOE,QAAQG,UAAAA,EAAW3B,IAAI,CAAC,CAACmC,MAAKhE,MAAAA,MAAW;QAACgE;QAAKP,iBAAiBzD,MAAAA;OAAO,CAAA;AAGhF,aAAO;QACLE,MAAM;QACN+D,UAAU;QACVf,OAAOa;MACT;IACF,CAAA;IAEIG,aAAO,CAAClE,WAAUmE,GAAGnE,MAAAA,EAAOsC,GAAG;EAAA;AAEzC;AAKO,IAAM8B,SAAS,CAAC/B,WAAiCgC,aAAahC,OAAOC,GAAG;",
+  "names": ["Match", "Schema", "SchemaAST", "assertArgument", "DXN", "ObjectId", "FilterClass", "ast", "variance", "is", "value", "fromAst", "everything", "type", "typename", "props", "nothing", "filter", "id", "ids", "assertArgument", "every", "ObjectId", "isValid", "length", "schema", "isSchema", "isUnion", "typenames", "types", "map", "getTypeDXNFromSpecifier", "make", "filters", "toString", "dxn", "propsFilterToAst", "startsWith", "DXN", "fromTypename", "typeDXN", "tag", "key", "options", "metaKey", "metaVersion", "version", "text", "searchKind", "foreignKeys", "keys", "eq", "isRef", "TypeError", "operator", "noInline", "encode", "neq", "gt", "gte", "lt", "lte", "in$", "values", "contains", "value", "FilterClass", "type", "between", "from", "to", "_toUnixMs", "date", "getTime", "_timeRangeFilter", "field", "range", "filters", "after", "push", "operator", "before", "length", "everything", "and", "updated", "created", "childOf", "parents", "options", "items", "Array", "isArray", "dxns", "map", "item", "isRef", "dxn", "toString", "getDXN", "transitive", "not", "filter", "ast", "f", "or", "propsFilterToAst", "predicates", "idFilter", "assertArgument", "id", "Schema", "ObjectId", "pipe", "validateSync", "props", "Object", "fromEntries", "entries", "prop", "_value", "predicate", "processPredicate", "withReturnType", "when", "is", "_predicate", "Error", "nestedProps", "key", "typename", "orElse", "eq", "pretty", "prettyFilter"]
+}

package/dist/lib/neutral/{chunk-BNCCGLJN.mjs → chunk-BICZKPQG.mjs}

@@ -4,4 +4,4 @@ var SchemaRegistry_exports = {};
 export {
   SchemaRegistry_exports
 };
-//# sourceMappingURL=chunk-BNCCGLJN.mjs.map
+//# sourceMappingURL=chunk-BICZKPQG.mjs.map

package/dist/lib/neutral/{chunk-QWAOTFCY.mjs → chunk-BMB7IHGB.mjs}

@@ -1,12 +1,12 @@
 import {
   Service
-} from "./chunk-EBVB5NOH.mjs";
+} from "./chunk-I2DARWPX.mjs";
 import {
   ReferenceAnnotationId,
   getSchemaDXN,
   getTypeAnnotation,
   getTypeIdentifierAnnotation
-} from "./chunk-6URFBQJH.mjs";
+} from "./chunk-TNBK56IN.mjs";
 
 // src/internal/Ref/ref.ts
 import * as Effect from "effect/Effect";
@@ -75,15 +75,7 @@ Ref.make = (obj) => {
     throw new TypeError("Expected: ECHO object.");
   }
   const id = obj.id;
-  invariant(ObjectId.isValid(id), "Invalid object ID", {
-    F: __dxlog_file,
-    L: 225,
-    S: void 0,
-    A: [
-      "ObjectId.isValid(id)",
-      "'Invalid object ID'"
-    ]
-  });
+  invariant(ObjectId.isValid(id), "Invalid object ID", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 76, S: void 0, A: ["ObjectId.isValid(id)", "'Invalid object ID'"] });
   const dxn = DXN.fromLocalObjectId(id);
   return new RefImpl(dxn, obj);
 };
@@ -185,15 +177,7 @@ var RefImpl = class _RefImpl {
     if (this.#target) {
       return this.#target;
     }
-    invariant(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file,
-      L: 393,
-      S: this,
-      A: [
-        "this.#resolver",
-        "'Resolver is not set'"
-      ]
-    });
+    invariant(this.#resolver, "Resolver is not set", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 181, S: this, A: ["this.#resolver", "'Resolver is not set'"] });
     return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback);
   }
   /**
@@ -203,15 +187,7 @@ var RefImpl = class _RefImpl {
     if (this.#target) {
       return this.#target;
     }
-    invariant(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file,
-      L: 404,
-      S: this,
-      A: [
-        "this.#resolver",
-        "'Resolver is not set'"
-      ]
-    });
+    invariant(this.#resolver, "Resolver is not set", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 190, S: this, A: ["this.#resolver", "'Resolver is not set'"] });
     const obj = await this.#resolver.resolve(this.#dxn);
     if (obj == null) {
       throw new Error("Object not found");
@@ -225,18 +201,16 @@ var RefImpl = class _RefImpl {
     if (this.#target) {
       return this.#target;
     }
-    invariant(this.#resolver, "Resolver is not set", {
-      F: __dxlog_file,
-      L: 419,
-      S: this,
-      A: [
-        "this.#resolver",
-        "'Resolver is not set'"
-      ]
-    });
+    invariant(this.#resolver, "Resolver is not set", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 203, S: this, A: ["this.#resolver", "'Resolver is not set'"] });
     return await this.#resolver.resolve(this.#dxn);
   }
   /**
+  * @inheritdoc
+  */
+  onResolved(callback) {
+    return this.#resolved.on(callback);
+  }
+  /**
   * Do not inline the target object in the reference.
   * Makes .target unavailable unless the reference is connected to a database context.
   * Clones the reference object.
@@ -305,27 +279,11 @@ var RefImpl = class _RefImpl {
   }
 };
 var setRefResolver = (ref, resolver) => {
-  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
-    F: __dxlog_file,
-    L: 506,
-    S: void 0,
-    A: [
-      "ref instanceof RefImpl",
-      "'Ref is not an instance of RefImpl'"
-    ]
-  });
+  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 277, S: void 0, A: ["ref instanceof RefImpl", "'Ref is not an instance of RefImpl'"] });
   ref._setResolver(resolver);
 };
 var getRefSavedTarget = (ref) => {
-  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", {
-    F: __dxlog_file,
-    L: 514,
-    S: void 0,
-    A: [
-      "ref instanceof RefImpl",
-      "'Ref is not an instance of RefImpl'"
-    ]
-  });
+  invariant(ref instanceof RefImpl, "Ref is not an instance of RefImpl", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 283, S: void 0, A: ["ref instanceof RefImpl", "'Ref is not an instance of RefImpl'"] });
   return ref._getSavedTarget();
 };
 var refVariance = {
@@ -348,15 +306,7 @@ var StaticRefResolver = class {
   }
   addSchema(schema) {
     const dxn = getSchemaDXN(schema);
-    invariant(dxn, "Schema has no DXN", {
-      F: __dxlog_file,
-      L: 546,
-      S: this,
-      A: [
-        "dxn",
-        "'Schema has no DXN'"
-      ]
-    });
+    invariant(dxn, "Schema has no DXN", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 308, S: this, A: ["dxn", "'Schema has no DXN'"] });
     this.schemas.set(dxn.toString(), schema);
     return this;
   }
@@ -393,4 +343,4 @@ export {
   refFromEncodedReference,
   StaticRefResolver
 };
-//# sourceMappingURL=chunk-QWAOTFCY.mjs.map
+//# sourceMappingURL=chunk-BMB7IHGB.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Ref/ref.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Hash from 'effect/Hash';\nimport * as Option from 'effect/Option';\nimport * as ParseResult from 'effect/ParseResult';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { Event } from '@dxos/async';\nimport { type CustomInspectFunction, inspectCustom } from '@dxos/debug';\nimport { EncodedReference } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport * as Database from '../../Database';\nimport { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../Annotation';\nimport type { AnyEntity, AnyProperties } from '../common/types';\nimport { type JsonSchemaType } from '../JsonSchema';\n\n/**\n * The `$id` and `$ref` fields for an ECHO reference schema.\n */\nexport const JSON_SCHEMA_ECHO_REF_ID = '/schemas/echo/ref';\n\nexport const getSchemaReference = (property: JsonSchemaType): { typename: string } | undefined => {\n  const { $id, reference: { schema: { $ref } = {} } = {} } = property;\n  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {\n    return { typename: DXN.parse($ref).typename };\n  }\n};\n\nexport const createSchemaReference = (typename: string): Types.DeepMutable<JsonSchemaType> => {\n  return {\n    $id: JSON_SCHEMA_ECHO_REF_ID,\n    reference: {\n      schema: {\n        $ref: DXN.fromTypename(typename).toString(),\n      },\n    },\n  };\n};\n\n/**\n * Runtime type-info for a reference extracted from effect AST.\n */\nexport type RefereneAST = {\n  /**\n   * Typename of linked schema.\n   */\n  typename: string;\n\n  /**\n   * Version of linked schema.\n   */\n  version: string;\n};\n\nexport const getReferenceAst = (ast: SchemaAST.AST): RefereneAST | undefined => {\n  if (ast._tag !== 'Declaration' || !ast.annotations[ReferenceAnnotationId]) {\n    return undefined;\n  }\n  return {\n    typename: (ast.annotations[ReferenceAnnotationId] as any).typename,\n    version: (ast.annotations[ReferenceAnnotationId] as any).version,\n  };\n};\n\nexport const RefTypeId: unique symbol = Symbol('@dxos/echo/internal/Ref');\n\n/**\n * Reference Schema.\n */\nexport interface RefSchema<T extends AnyEntity> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}\n\n/**\n * Type of the `Ref` function and extra methods attached to it.\n */\nexport interface RefFn {\n  <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>>;\n\n  /**\n   * @returns True if the object is a reference.\n   */\n  isRef: (obj: unknown) => obj is Ref<any>;\n\n  /**\n   * @returns True if the reference points to the given object id.\n   */\n  hasObjectId: (id: ObjectId) => (ref: Ref<any>) => boolean;\n\n  /**\n   * @returns True if the schema is a reference schema.\n   */\n  isRefSchema: (schema: Schema.Schema<any, any>) => schema is RefSchema<any>;\n\n  /**\n   * @returns True if the schema AST is a reference schema.\n   */\n  isRefSchemaAST: (ast: SchemaAST.AST) => boolean;\n\n  /**\n   * Constructs a reference that points to the given object.\n   */\n  // TODO(burdon): Narrow to Obj.Unknown?\n  make: <T extends AnyEntity>(object: T) => Ref<T>;\n\n  /**\n   * Constructs a reference that points to the object specified by the provided DXN.\n   */\n  fromDXN: (dxn: DXN) => Ref<any>;\n}\n\n/**\n * Schema builder for references.\n */\nexport const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>> => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'Must call with an instance of effect-schema');\n  const annotation = getTypeAnnotation(schema);\n  if (annotation == null) {\n    throw new Error('Reference target must be an ECHO schema.');\n  }\n\n  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);\n};\n\n/**\n * Represents materialized reference to a target.\n * This is the data type for the fields marked as ref.\n */\nexport interface Ref<T> extends Pipeable.Pipeable {\n  /**\n   * Target object DXN.\n   */\n  get dxn(): DXN;\n\n  /**\n   * Returns true if the reference has a target available (inlined or resolver set).\n   */\n  get isAvailable(): boolean;\n\n  /**\n   * @returns The reference target.\n   * May return `undefined` if the object is not loaded in the working set.\n   * Accessing this property, even if it returns `undefined` will trigger the object to be loaded to the working set.\n   */\n  get target(): T | undefined;\n\n  /**\n   * @returns Promise that will resolves with the target object.\n   * Will load the object from disk if it is not present in the working set.\n   * @throws If the object is not available locally.\n   */\n  load(): Promise<T>;\n\n  /**\n   * @returns Promise that will resolves with the target object or undefined if the object is not loaded locally.\n   */\n\n  tryLoad(): Promise<T | undefined>;\n\n  /**\n   * Subscribe to the ref's resolution event.\n   * The callback fires when the target object becomes available in the working set\n   * (e.g. when its document is loaded after sibling-client mutation).\n   * Note: the resolver only schedules a notification when the target is requested\n   * via {@link target} while it is not yet loaded.\n   * @returns Function that unsubscribes the callback.\n   */\n  onResolved(callback: () => void): () => void;\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   *\n   * When serialized with toJSON, the difference is between:\n   * `{ \"/\": \"dxn:...\" }`\n   * and\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   *\n   * Clones the reference object.\n   */\n  noInline(): Ref<T>;\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   *\n   * Examples:\n   * `{ \"/\": \"dxn:...\" }`\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   */\n  encode(): EncodedReference;\n\n  [RefTypeId]: {\n    _T: T;\n  };\n}\n\nexport declare namespace Ref {\n  /**\n   * Target of the reference.\n   */\n  export type Target<R> = R extends Ref<infer U> ? U : never;\n}\n\nRef.isRef = (obj: any): obj is Ref<any> => {\n  return obj && typeof obj === 'object' && RefTypeId in obj;\n};\n\nRef.hasObjectId = (id: ObjectId) => (ref: Ref<any>) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;\n\nRef.isRefSchema = (schema: Schema.Schema<any, any>): schema is RefSchema<any> => {\n  return Ref.isRefSchemaAST(schema.ast);\n};\n\nRef.isRefSchemaAST = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);\n};\n\nRef.make = <T extends AnyProperties>(obj: T): Ref<T> => {\n  if (typeof obj !== 'object' || obj === null) {\n    throw new TypeError('Expected: ECHO object.');\n  }\n\n  // TODO(dmaretskyi): Extract to `getObjectDXN` function.\n  const id = obj.id;\n  invariant(ObjectId.isValid(id), 'Invalid object ID');\n  const dxn = DXN.fromLocalObjectId(id);\n  return new RefImpl(dxn, obj);\n};\n\nRef.fromDXN = (dxn: DXN): Ref<any> => {\n  assertArgument(dxn instanceof DXN, 'dxn', 'Expected DXN');\n  return new RefImpl(dxn);\n};\n\n/**\n * `reference` field on the schema object.\n */\nexport type JsonSchemaReferenceInfo = {\n  schema: { $ref: string };\n  schemaVersion?: string;\n};\n\n/**\n * @internal\n */\n// TODO(burdon): Move to json schema and make private?\nexport const createEchoReferenceSchema = (\n  echoId: string | undefined,\n  typename: string | undefined,\n  version: string | undefined,\n): Schema.SchemaClass<Ref<any>, EncodedReference> => {\n  if (!echoId && !typename) {\n    throw new TypeError('Either echoId or typename must be provided.');\n  }\n\n  const referenceInfo: JsonSchemaReferenceInfo = {\n    schema: {\n      // TODO(dmaretskyi): Include version?\n      $ref: echoId ?? DXN.fromTypename(typename!).toString(),\n    },\n    schemaVersion: version,\n  };\n\n  // TODO(dmaretskyi): Add name and description.\n  const refSchema = Schema.declare<Ref<any>, EncodedReference, []>(\n    [],\n    {\n      encode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            if (Ref.isRef(value)) {\n              return EncodedReference.fromDXN((value as Ref<any>).dxn);\n            } else if (EncodedReference.isEncodedReference(value)) {\n              return value;\n            }\n            throw new Error('Invalid reference');\n          });\n      },\n      decode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            const dbService = yield* Effect.serviceOption(Database.Service);\n\n            // TODO(dmaretskyi): This branch seems to be taken by Schema.is\n            if (Ref.isRef(value)) {\n              if (Option.isSome(dbService)) {\n                return dbService.value.db.makeRef(value.dxn);\n              } else {\n                return value;\n              }\n            }\n\n            if (!EncodedReference.isEncodedReference(value)) {\n              return yield* Effect.fail(new ParseResult.Unexpected(value, 'reference'));\n            }\n            if (Option.isSome(dbService)) {\n              return dbService.value.db.makeRef(EncodedReference.toDXN(value));\n            } else {\n              return Ref.fromDXN(EncodedReference.toDXN(value));\n            }\n          });\n      },\n    },\n    {\n      jsonSchema: {\n        // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.\n        $id: JSON_SCHEMA_ECHO_REF_ID,\n        $ref: JSON_SCHEMA_ECHO_REF_ID,\n        reference: referenceInfo,\n      },\n      [ReferenceAnnotationId]: {\n        typename: typename ?? '',\n        version,\n      },\n    },\n  );\n\n  return refSchema;\n};\n\nconst getSchemaExpectedName = (ast: SchemaAST.Annotated): string | undefined => {\n  return SchemaAST.getIdentifierAnnotation(ast).pipe(\n    Option.orElse(() => SchemaAST.getTitleAnnotation(ast)),\n    Option.orElse(() => SchemaAST.getDescriptionAnnotation(ast)),\n    Option.getOrElse(() => undefined),\n  );\n};\n\nexport interface RefResolver {\n  /**\n   * Resolve ref synchronously from the objects in the working set.\n   *\n   * @param dxn\n   * @param load If true the resolver should attempt to load the object from disk.\n   * @param onLoad Callback to call when the object is loaded.\n   */\n  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): AnyProperties | undefined;\n\n  /**\n   * Resolver ref asynchronously.\n   */\n  resolve(dxn: DXN): Promise<AnyProperties | undefined>;\n\n  // TODO(dmaretskyi): Combine with `resolve`.\n  resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined>;\n}\n\nexport class RefImpl<T> implements Ref<T> {\n  #dxn: DXN;\n  #resolver?: RefResolver = undefined;\n  #resolved = new Event<void>();\n\n  /**\n   * Target is set when the reference is created from a specific object.\n   * In this case, the target might not be in the database.\n   */\n  #target: T | undefined = undefined;\n\n  /**\n   * Callback to issue a reactive notification when object is resolved.\n   */\n  #resolverCallback = () => {\n    this.#resolved.emit();\n  };\n\n  constructor(dxn: DXN, target?: T) {\n    this.#dxn = dxn;\n    this.#target = target;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get dxn(): DXN {\n    return this.#dxn;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get isAvailable(): boolean {\n    return this.#target !== undefined || this.#resolver !== undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get target(): T | undefined {\n    if (this.#target) {\n      return this.#target;\n    }\n\n    invariant(this.#resolver, 'Resolver is not set');\n    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async load(): Promise<T> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    const obj = await this.#resolver.resolve(this.#dxn);\n    if (obj == null) {\n      throw new Error('Object not found');\n    }\n    return obj as T;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async tryLoad(): Promise<T | undefined> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    return (await this.#resolver.resolve(this.#dxn)) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  onResolved(callback: () => void): () => void {\n    return this.#resolved.on(callback);\n  }\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   * Clones the reference object.\n   */\n  noInline(): RefImpl<T> {\n    const ref = new RefImpl<T>(this.#dxn, undefined);\n    ref.#resolver = this.#resolver;\n    return ref;\n  }\n\n  encode(): EncodedReference {\n    return {\n      '/': this.#dxn.toString(),\n      ...(this.#target ? { target: this.#target } : {}),\n    };\n  }\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   */\n  toJSON(): EncodedReference {\n    return this.encode();\n  }\n\n  toString(): string {\n    if (this.#target) {\n      return `Ref(${this.#target.toString()})`;\n    }\n\n    return `Ref(${this.#dxn.toString()})`;\n  }\n\n  [inspectCustom]: CustomInspectFunction = (depth, options, inspect) => {\n    return this.toString();\n  };\n\n  [RefTypeId] = refVariance;\n\n  /**\n   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)\n   * to deduplicate Ref instances that point to the same object.\n   * ECHO proxies return new RefImpl instances on every property access,\n   * so without this, each access would create a separate cache entry.\n   */\n  [Hash.symbol](): number {\n    return Hash.hash(this.#dxn.toString());\n  }\n\n  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return that instanceof RefImpl && this.#dxn.toString() === that.dxn.toString();\n  }\n\n  /**\n   * Internal method to set the resolver.\n   *\n   * @internal\n   */\n  _setResolver(resolver: RefResolver): void {\n    this.#resolver = resolver;\n  }\n\n  /**\n   * @internal\n   */\n  _getSavedTarget(): T | undefined {\n    return this.#target;\n  }\n\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params\n    return Pipeable.pipeArguments(this, arguments);\n  }\n}\n\n/**\n * Internal API for setting the reference resolver.\n */\nexport const setRefResolver = (ref: Ref<any>, resolver: RefResolver) => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  ref._setResolver(resolver);\n};\n\n/**\n * Internal API for getting the saved target on a reference.\n */\nexport const getRefSavedTarget = (ref: Ref<any>): AnyProperties | undefined => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  return ref._getSavedTarget();\n};\n\n// Used to validate reference target type.\nconst refVariance: Ref<any>[typeof RefTypeId] = {\n  _T: null as any,\n};\n\nexport const refFromEncodedReference = (encodedReference: EncodedReference, resolver?: RefResolver): Ref<any> => {\n  const dxn = DXN.parse(encodedReference['/']);\n  const ref = new RefImpl(dxn);\n\n  // TODO(dmaretskyi): Handle inline target in the encoded reference.\n\n  if (resolver) {\n    setRefResolver(ref, resolver);\n  }\n  return ref;\n};\n\nexport class StaticRefResolver implements RefResolver {\n  public objects = new Map<ObjectId, AnyProperties>();\n  public schemas = new Map<DXN.String, Schema.Schema.AnyNoContext>();\n\n  addObject(obj: AnyProperties): this {\n    this.objects.set(obj.id, obj);\n    return this;\n  }\n\n  addSchema(schema: Schema.Schema.AnyNoContext): this {\n    const dxn = getSchemaDXN(schema);\n    invariant(dxn, 'Schema has no DXN');\n    this.schemas.set(dxn.toString(), schema);\n    return this;\n  }\n\n  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): AnyProperties | undefined {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolve(dxn: DXN): Promise<AnyProperties | undefined> {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined> {\n    return this.schemas.get(dxn.toString());\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["Effect", "Equal", "Hash", "Option", "ParseResult", "Pipeable", "Schema", "SchemaAST", "Event", "inspectCustom", "EncodedReference", "assertArgument", "invariant", "DXN", "ObjectId", "reference", "$ref", "$id", "JSON_SCHEMA_ECHO_REF_ID", "typename", "schema", "undefined", "version", "annotation", "getTypeAnnotation", "Error", "createEchoReferenceSchema", "isRef", "obj", "hasObjectId", "ref", "isLocalObjectId", "Ref", "isRefSchemaAST", "ast", "make", "TypeError", "dxn", "DXN", "fromDXN", "RefImpl", "referenceInfo", "schemaVersion", "Effect", "gen", "EncodedReference", "value", "dbService", "Option", "isSome", "jsonSchema", "ReferenceAnnotationId", "getSchemaExpectedName", "undefined", "target", "invariant", "obj", "Error", "ref", "encode", "toString", "inspectCustom", "depth", "options", "inspect", "RefTypeId", "refVariance", "pipe", "_setResolver", "resolver", "_getSavedTarget", "dxn", "schemas", "addObject", "objects", "set", "addSchema", "schema", "resolveSync", "id", "resolve", "resolveSchema"]
+}

package/dist/lib/neutral/{chunk-KPY6FC5I.mjs → chunk-BVOWYVTD.mjs}

@@ -1,11 +1,11 @@
 import {
   isRef
-} from "./chunk-46QNGNTY.mjs";
+} from "./chunk-N7VOEPSV.mjs";
 import {
   Kind,
   KindId,
   SnapshotKindId
-} from "./chunk-2U2BZDLU.mjs";
+} from "./chunk-SCPFDS2E.mjs";
 import {
   EchoObjectSchema,
   MetaId,
@@ -38,7 +38,7 @@ import {
   subscribe,
   version,
   versionValid
-} from "./chunk-WMFVS4KR.mjs";
+} from "./chunk-G54OX4IX.mjs";
 import {
   ParentId,
   getDescription,
@@ -50,15 +50,15 @@ import {
   isInstanceOf,
   setDescription,
   setLabel
-} from "./chunk-6URFBQJH.mjs";
+} from "./chunk-TNBK56IN.mjs";
 import {
   ANY_OBJECT_TYPENAME,
   ANY_OBJECT_VERSION,
   SchemaKindId
-} from "./chunk-TBKX6JQO.mjs";
+} from "./chunk-N4B7FHQT.mjs";
 import {
   GetReactiveError
-} from "./chunk-UBEZSGXY.mjs";
+} from "./chunk-ZISMEVKD.mjs";
 import {
   __export
 } from "./chunk-J5LGTIGS.mjs";
@@ -72,7 +72,6 @@ __export(Obj_exports, {
   Unknown: () => Unknown2,
   VersionTypeId: () => VersionTypeId2,
   addTag: () => addTag2,
-  change: () => change2,
   clone: () => clone2,
   compareVersions: () => compareVersions2,
   decodeVersion: () => decodeVersion2,
@@ -111,6 +110,7 @@ __export(Obj_exports, {
   sortByTypename: () => sortByTypename2,
   subscribe: () => subscribe2,
   toJSON: () => toJSON,
+  update: () => update,
   updateFrom: () => updateFrom,
   version: () => version2,
   versionValid: () => versionValid2
@@ -122,9 +122,10 @@ import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Utils from "effect/Utils";
 import { createJsonPath } from "@dxos/effect";
-import { assertArgument } from "@dxos/invariant";
+import { assertArgument, invariant } from "@dxos/invariant";
 import { ObjectId } from "@dxos/keys";
 import { assumeType, deepMapValues } from "@dxos/util";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/Obj.ts";
 var Unknown2 = Schema.Struct({
   id: Schema.String
 }).pipe(
@@ -200,7 +201,7 @@ var getReactive = (snapshot) => Effect.gen(function* () {
 var getReactiveOption = (snapshot) => getReactive(snapshot).pipe(Effect.map(Option.some), Effect.catchAll(() => Effect.succeed(Option.none())));
 var getReactiveOrThrow = (snapshot) => Effect.runSync(getReactive(snapshot));
 var clone2 = clone;
-var change2 = (obj, callback) => {
+var update = (obj, callback) => {
   change(obj, callback);
 };
 var getValue2 = (obj, path) => {
@@ -225,7 +226,11 @@ var getDXN2 = (entity) => {
   assertArgument(!Schema.isSchema(entity), "obj", "Object should not be a schema.");
   return getDXN(entity);
 };
-var getTypeDXN2 = getTypeDXN;
+var getTypeDXN2 = (obj) => {
+  const type = getTypeDXN(obj);
+  invariant(type != null, "Corrupted object: missing type.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 315, S: void 0, A: ["type != null", "'Corrupted object: missing type.'"] });
+  return type;
+};
 var getSchema2 = getSchema;
 var getTypename2 = (entity) => getTypename(entity);
 var getDatabase2 = (entity) => getDatabase(entity);
@@ -372,7 +377,7 @@ export {
   getReactiveOption,
   getReactiveOrThrow,
   clone2 as clone,
-  change2 as change,
+  update,
   getValue2 as getValue,
   setValue2 as setValue,
   ID,
@@ -412,4 +417,4 @@ export {
   version2 as version,
   Obj_exports
 };
-//# sourceMappingURL=chunk-KPY6FC5I.mjs.map
+//# sourceMappingURL=chunk-BVOWYVTD.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Obj.ts"],
+  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Function from 'effect/Function';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport * as Utils from 'effect/Utils';\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { createJsonPath } from '@dxos/effect';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { type DXN, ObjectId } from '@dxos/keys';\nimport { assumeType, deepMapValues } from '@dxos/util';\n\nimport type * as Database from './Database';\nimport * as Entity from './Entity';\nimport * as Err from './Err';\nimport * as internal from './internal';\nimport { getProxyTarget, isProxy } from './internal/common/proxy/proxy-utils';\nimport * as objInternal from './internal/Obj';\nimport * as Ref from './Ref';\nimport type * as Type from './Type';\n\n/**\n * Base type for all ECHO objects.\n */\ninterface BaseObj extends internal.AnyEntity, Entity.OfKind<typeof Entity.Kind.Object> {}\n\n/**\n * Object type with specific properties.\n */\nexport type OfShape<Props> = BaseObj & Props;\n\n/**\n * Object with no known properties beyond id and kind.\n * Use this when the object's schema/properties are not known.\n * For objects with arbitrary properties, use `Obj.AnyProps`.\n *\n * NOTE: This is a TypeScript type only, not a schema.\n * To validate that a value is an ECHO object, use `Schema.is(Type.Obj)`.\n */\nexport interface Unknown extends BaseObj {}\n\n/**\n * Runtime Effect schema for any ECHO object.\n * Use for validation, parsing, or as a reference target for collections.\n *\n * NOTE: `Schema.is(Type.Obj)` does STRUCTURAL validation only (checks for `id` field).\n * Use `Obj.isObject()` for proper ECHO instance type guards that check the KindId brand.\n *\n * @example\n * ```ts\n * // Structural type guard (accepts any object with id field)\n * if (Schema.is(Type.Obj)(unknownValue)) { ... }\n *\n * // ECHO instance type guard (checks KindId brand)\n * if (Obj.isObject(unknownValue)) { ... }\n *\n * // Reference to any object type\n * const Collection = Schema.Struct({\n *   objects: Schema.Array(Ref.Ref(Obj.Unknown)),\n * }).pipe(Type.object({ typename: 'Collection', version: '0.1.0' }));\n * ```\n */\n// TODO(wittjosiah): Investigate if Schema.filter can validate KindId on ECHO instances.\n//   Effect Schema normalizes proxy objects to plain objects before calling filter predicates.\n//   Possible approaches: custom Schema.declare, AST manipulation, or upstream contribution.\nexport const Unknown: Type.Obj<Unknown> = Schema.Struct({\n  id: Schema.String,\n}).pipe(\n  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),\n  // TODO(dmaretskyi): Clean this up.\n  // NOTE: The EchoObjectSchema annotation is required for Ref.Ref(Obj.Unknown) to work.\n  //   The typename/version only satisfy ECHO schema machinery for reference targets.\n  internal.EchoObjectSchema({ typename: internal.ANY_OBJECT_TYPENAME, version: internal.ANY_OBJECT_VERSION }),\n  (schema) =>\n    Object.assign(schema, {\n      [internal.SchemaKindId]: (schema as any)[internal.SchemaKindId],\n    }) as unknown as Type.Obj<Unknown>,\n);\n\n/**\n * Object with arbitrary properties.\n *\n * NOTE: Due to how TypeScript works, this type is not assignable to a specific schema type.\n * In that case, use `Obj.instanceOf` to check if an object is of a specific type.\n *\n * Prefer using `Obj.Unknown` when you don't need to access arbitrary properties.\n */\nexport interface Any extends BaseObj, internal.AnyProperties {}\n\n/**\n * Base type for snapshot objects (has SnapshotKindId instead of KindId).\n */\ninterface BaseSnapshot extends internal.AnyEntity {\n  readonly [Entity.SnapshotKindId]: typeof Entity.Kind.Object;\n  readonly id: ObjectId;\n}\n\n/**\n * Immutable snapshot of an ECHO object.\n * Branded with SnapshotKindId (not KindId).\n * Property values are frozen at the time the snapshot was created.\n * Returned by getSnapshot() and hooks like useObject().\n *\n * Snapshots are structurally identical to reactive objects but have a different brand,\n * making them distinguishable at the TypeScript level. Neither is assignable to the other.\n */\nexport type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> & BaseSnapshot;\n\n/**\n * JSON-encoded properties for objects.\n */\nexport interface BaseObjJson {\n  id: string;\n}\n\nconst defaultMeta: internal.ObjectMeta = {\n  keys: [],\n};\n\ntype MakePropsInternal<T extends Unknown> = {\n  id?: ObjectId;\n  [Meta]?: Partial<internal.ObjectMeta>;\n} & Entity.Properties<T>;\n\n// TODO(burdon): Should we allow the caller to set the id?\n/**\n * Props type for object creation with a given schema.\n */\nexport type MakeProps<S extends Schema.Schema.AnyNoContext> = {\n  id?: ObjectId;\n  [Meta]?: Partial<internal.ObjectMeta>;\n  [Parent]?: Unknown;\n} & MakePropsInternal<Schema.Schema.Type<S>>;\n\n/**\n * Creates a new echo object of the given schema.\n * @param schema - Object schema.\n * @param props - Object properties.\n * @param meta - Object metadata (deprecated) -- pass with Obj.Meta.\n *\n * Meta can be passed as a symbol in `props`.\n *\n * Example:\n * ```ts\n * const obj = Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' });\n * ```\n *\n * Note: Only accepts object schemas, not relation schemas. Use `Relation.make` for relations.\n */\nexport const make = <S extends Type.AnyObj>(\n  schema: S,\n  props: NoInfer<MakeProps<S>>,\n): OfShape<Schema.Schema.Type<S>> => {\n  assertArgument(\n    internal.getTypeAnnotation(schema)?.kind === Entity.Kind.Object,\n    'schema',\n    'Expected an object schema',\n  );\n\n  let meta: internal.ObjectMeta | undefined = undefined;\n\n  // Set default fields on meta on creation.\n  if (props[internal.MetaId] != null) {\n    meta = { ...structuredClone(defaultMeta), ...props[internal.MetaId] };\n    delete props[internal.MetaId];\n  }\n\n  // Filter undefined values (Object.entries only returns string-keyed properties).\n  const filterUndefined: any = Object.fromEntries(Object.entries(props).filter(([_, v]) => v !== undefined));\n\n  // Copy symbol properties (like ParentId) that Object.entries doesn't include.\n  for (const sym of Object.getOwnPropertySymbols(props)) {\n    const value = (props as any)[sym];\n    if (value !== undefined) {\n      filterUndefined[sym] = value;\n    }\n  }\n\n  return internal.makeObject<Schema.Schema.Type<S>>(schema, filterUndefined as any, {\n    ...defaultMeta,\n    ...meta,\n  });\n};\n\n/**\n * Determine if object is an ECHO object.\n */\nexport const isObject = (obj: unknown): obj is Unknown => {\n  assumeType<internal.InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && obj[Entity.KindId] === Entity.Kind.Object;\n};\n\nexport const isSnapshot = (obj: unknown): obj is Snapshot => {\n  assumeType<internal.InternalObjectProps>(obj);\n  return typeof obj === 'object' && obj !== null && (obj as any)[Entity.SnapshotKindId] === Entity.Kind.Object;\n};\n\n/**\n * Subscribe to object updates.\n * The callback is called synchronously when the object is modified.\n * Only accepts reactive objects (not snapshots).\n * @returns Unsubscribe function.\n */\nexport const subscribe = (obj: Unknown, callback: () => void): (() => void) => {\n  return internal.subscribe(obj, callback);\n};\n\n//\n// Snapshot\n//\n\n/**\n * Returns an immutable snapshot of an object.\n * The snapshot is branded with SnapshotKindId instead of KindId,\n * making it distinguishable from the reactive object at the type level.\n */\nexport const getSnapshot: <T extends Unknown>(obj: T) => Snapshot<T> = objInternal.getSnapshot as any;\n\n/**\n * Returns the reactive version of an object from the database, given its snapshot.\n * Inverse of `Obj.getSnapshot`.\n *\n * Uses `Obj.getDatabase` internally to get the database from the snapshot,\n * then resolves the reactive object by ID.\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns Effect that succeeds with the reactive object, or fails with `GetReactiveError`.\n * @example\n * ```ts\n * const snapshot = Obj.getSnapshot(obj);\n * const reactive = Obj.getReactive(snapshot).pipe(\n *   Effect.runSync\n * );\n * ```\n */\nexport const getReactive = <T extends Unknown>(snapshot: Snapshot<T>): Effect.Effect<T, Err.GetReactiveError> =>\n  Effect.gen(function* () {\n    const db = internal.getDatabase(snapshot);\n    if (!db) {\n      return yield* Effect.fail(new Err.GetReactiveError({ reason: 'no-database', snapshotId: snapshot.id }));\n    }\n    const obj = db.getObjectById(snapshot.id);\n    if (!obj) {\n      return yield* Effect.fail(new Err.GetReactiveError({ reason: 'object-not-found', snapshotId: snapshot.id }));\n    }\n    return obj as T;\n  });\n\n/**\n * Like `Obj.getReactive` but returns `Option.none()` instead of failing when the object\n * cannot be resolved (no database, object not found).\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns Effect that succeeds with `Option.some(reactive)` or `Option.none()`.\n */\nexport const getReactiveOption = <T extends Unknown>(snapshot: Snapshot<T>): Effect.Effect<Option.Option<T>, never> =>\n  getReactive(snapshot).pipe(\n    Effect.map(Option.some),\n    Effect.catchAll(() => Effect.succeed(Option.none())),\n  );\n\n/**\n * Synchronous version of `Obj.getReactive`. Returns the reactive object or throws\n * `GetReactiveError` when the object cannot be resolved (no database, object not found).\n *\n * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).\n * @returns The reactive object.\n * @throws {Err.GetReactiveError} When the object cannot be resolved.\n */\nexport const getReactiveOrThrow = <T extends Unknown>(snapshot: Snapshot<T>): T =>\n  Effect.runSync(getReactive(snapshot));\n\nexport type CloneOptions = {\n  /**\n   * Retain the original object's ID.\n   * @default false\n   */\n  retainId?: boolean;\n\n  /**\n   * Recursively clone referenced objects.\n   * @default false\n   */\n  deep?: boolean;\n};\n\n/**\n * Clones an object or relation.\n * This does not clone referenced objects, only the properties in the object.\n * @returns A new object with the same schema and properties.\n */\nexport const clone: <T extends Unknown>(obj: T, opts?: CloneOptions) => T = objInternal.clone;\n\n//\n// Change\n//\n\n/**\n * Makes all properties mutable recursively.\n * Used to provide a mutable view of an object within `Obj.update`.\n */\nexport type Mutable<T> = internal.Mutable<T>;\n\n/**\n * Perform mutations on an echo object within a controlled context.\n *\n * All mutations within the callback are batched and trigger a single notification\n * when the callback completes. Direct mutations outside of `Obj.update` will throw\n * an error for echo objects.\n *\n * This function also works with nested objects within echo objects (e.g., Template structs)\n * that are reactive at runtime.\n *\n * @param obj - The echo object to mutate. Use `Relation.update` for relations.\n * @param callback - The callback that performs mutations on the object.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John', age: 25 });\n *\n * // Mutate within Obj.update\n * Obj.update(person, (obj) => {\n *   obj.name = 'Jane';\n *   obj.age = 30;\n * });\n * // ONE notification fires here\n *\n * // Direct mutation throws\n * person.name = 'Bob'; // Error: Cannot modify outside Obj.update()\n * ```\n *\n * Note: Only accepts objects. Use `Relation.update` for relations.\n */\nexport const update = <T extends Unknown>(obj: T, callback: internal.ChangeCallback<T>): void => {\n  internal.change(obj, callback);\n};\n\n/**\n * Get a deeply nested property from an object.\n *\n * Similar to lodash.get and getDeep from @dxos/util.\n * This is the complementary function to setValue.\n * Accepts both reactive objects and snapshots.\n *\n * @param obj - The ECHO object to get the property from.\n * @param path - Path to the property (array of keys).\n * @returns The value at the path, or undefined if not found.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, {\n *   name: 'John',\n *   addresses: [{ street: '123 Main St' }]\n * });\n *\n * Obj.getValue(person, ['addresses', 0, 'street']); // '123 Main St'\n * Obj.getValue(person, ['addresses', 1, 'street']); // undefined\n * ```\n */\nexport const getValue = (obj: Unknown | Snapshot, path: readonly (string | number)[]): any => {\n  return internal.getValue(obj, createJsonPath(path));\n};\n\n/**\n * Set a deeply nested property on an object, using the object's schema to determine\n * whether to initialize nested data as an empty object or array.\n *\n * Similar to lodash.set and setDeep from @dxos/util, but schema-aware.\n * Must be called within an `Obj.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n *\n * @param obj - The mutable ECHO object to set the property on.\n * @param path - Path to the property (array of keys).\n * @param value - Value to set.\n * @returns The value that was set.\n *\n * @example\n * ```ts\n * const person = Obj.make(Person, { name: 'John' });\n * // Person schema has: addresses: Schema.Array(Address)\n * Obj.update(person, (obj) => {\n *   Obj.setValue(obj, ['addresses', 0, 'street'], '123 Main St');\n * });\n * // Creates: person.addresses = [{ street: '123 Main St' }]\n * ```\n */\n// TODO(wittjosiah): Compute possible path values + type value based on generic object type.\nexport const setValue: (obj: Mutable<Unknown>, path: readonly (string | number)[], value: any) => void =\n  objInternal.setValue as any;\n\n//\n// Type\n//\n\n// TODO(burdon): To discuss: prefer over ObjectId or Key.ObjectId or Type.ID?\nexport const ID = ObjectId;\nexport type ID = ObjectId;\n\n/**\n * Test if object or relation is an instance of a schema.\n * @example\n * ```ts\n * const john = Obj.make(Person, { name: 'John' });\n * const isPerson = Obj.instanceOf(Person);\n * if (isPerson(john)) {\n *   // john is Person\n * }\n * ```\n */\nexport const instanceOf: {\n  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Schema.Schema.Type<S>;\n  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Schema.Schema.Type<S>;\n} = ((...args: [schema: Type.AnyEntity, value: unknown] | [schema: Type.AnyEntity]) => {\n  if (args.length === 1) {\n    return (entity: unknown) => internal.isInstanceOf(args[0], entity);\n  }\n\n  return internal.isInstanceOf(args[0], args[1]);\n}) as any;\n\n/**\n * Test if a snapshot is an instance of a schema.\n * Mirrors `instanceOf` but only accepts values branded with SnapshotKindId.\n * Use when the value is known to be a snapshot (e.g. from `getSnapshot` or `useObject`).\n *\n * @example\n * ```ts\n * const snapshot = Obj.getSnapshot(person);\n * if (Obj.snapshotOf(Person, snapshot)) {\n *   // snapshot is Obj.Snapshot<Person>\n * }\n * ```\n */\nexport const snapshotOf: {\n  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Snapshot<Schema.Schema.Type<S>>;\n  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Snapshot<Schema.Schema.Type<S>>;\n} = ((...args: [schema: Type.AnyEntity, value: unknown] | [schema: Type.AnyEntity]) => {\n  const check = (entity: unknown) =>\n    entity != null &&\n    typeof entity === 'object' &&\n    Entity.SnapshotKindId in entity &&\n    internal.isInstanceOf(args[0], entity);\n\n  if (args.length === 1) {\n    return (entity: unknown) => check(entity);\n  }\n\n  return check(args[1]);\n}) as any;\n\n// TODO(dmaretskyi): Allow returning undefined.\n/**\n * Get the DXN of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDXN = (entity: Unknown | Snapshot): DXN => {\n  assertArgument(!Schema.isSchema(entity), 'obj', 'Object should not be a schema.');\n  return internal.getDXN(entity);\n};\n\n/**\n * @returns The DXN of the object's type.\n * @example dxn:com.example.type.person:1.0.0\n * @throws If the object is missing its type (corrupted object).\n */\nexport const getTypeDXN = (obj: Unknown | Snapshot): DXN => {\n  const type = internal.getTypeDXN(obj);\n  invariant(type != null, 'Corrupted object: missing type.');\n  return type;\n};\n\n/**\n * Get the schema of the object.\n * Returns the branded ECHO schema used to create the object.\n */\nexport const getSchema: (obj: Unknown | Snapshot) => Type.AnyEntity | undefined = internal.getSchema as any;\n\n/**\n * @returns The typename of the object's type.\n * Accepts both reactive objects and snapshots.\n * @example `com.example.type.person`\n */\nexport const getTypename = (entity: Unknown | Snapshot): string | undefined => internal.getTypename(entity);\n\n//\n// Database\n//\n\n/**\n * Get the database the object belongs to.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDatabase = (entity: Entity.Unknown | Entity.Snapshot): Database.Database | undefined =>\n  internal.getDatabase(entity);\n\n//\n// Meta\n//\n\n/**\n * Property that accesses metadata for an entity.\n *\n * Alias for `Entity.Meta`.\n */\nexport const Meta = internal.MetaId;\n\n/**\n * Deeply read-only version of ObjectMeta.\n * Prevents mutation at all nesting levels (e.g., `meta.keys.push()` is a TypeScript error).\n */\nexport type ReadonlyMeta = internal.ReadonlyMeta;\n\n/**\n * Mutable meta type returned by `Obj.getMeta` inside an `Obj.update` callback.\n */\nexport type Meta = internal.Meta;\n\n// TODO(burdon): Narrow type.\n// TODO(dmaretskyi): Allow returning undefined.\n/**\n * Get the metadata for an object.\n * Returns mutable meta when passed a mutable object (inside `Obj.update` callback).\n * Returns read-only meta when passed a regular object or snapshot.\n *\n * @example\n * ```ts\n * // Read-only access outside change callback\n * const meta = Obj.getMeta(person);  // ReadonlyMeta\n *\n * // Mutable access inside change callback\n * Obj.update(person, (obj) => {\n *   const meta = Obj.getMeta(obj);     // ObjectMeta (mutable)\n *   meta.tags ??= [];\n *   meta.tags.push('important');\n * });\n * ```\n */\n// TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\nexport function getMeta(entity: Mutable<Unknown>): Meta;\nexport function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;\nexport function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): Meta | ReadonlyMeta {\n  return internal.getMetaChecked(entity);\n}\n\n/**\n * @returns Foreign keys for the object from the specified source.\n * Accepts both reactive objects and snapshots.\n */\nexport const getKeys: {\n  (entity: Unknown | Snapshot, source: string): ForeignKey[];\n  (source: string): (entity: Unknown | Snapshot) => ForeignKey[];\n} = Function.dual(2, (entity: Unknown | Snapshot, source?: string): ForeignKey[] => internal.getKeys(entity, source!));\n\n/**\n * Delete all keys from the object for the specified source.\n * Must be called within an `Obj.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const deleteKeys = (entity: Mutable<Unknown>, source: string): void => internal.deleteKeys(entity, source);\n\n/**\n * Add a tag to the object.\n * Must be called within an `Obj.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);\n\n/**\n * Remove a tag from the object.\n * Must be called within an `Obj.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);\n\n/**\n * Check if the object is deleted.\n * Accepts both reactive objects and snapshots.\n */\n// TODO(dmaretskyi): Default to `false`.\nexport const isDeleted = (entity: Unknown | Snapshot): boolean => objInternal.isDeleted(entity);\n\n//\n// Annotations\n//\n\n/**\n * Get the label of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getLabel = (entity: Unknown | Snapshot): string | undefined => internal.getLabel(entity);\n\n/**\n * Set the label of the object.\n * Must be called within an `Obj.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);\n\n/**\n * Get the description of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);\n\n/**\n * Set the description of the object.\n * Must be called within an `Obj.update` callback.\n *\n * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`\n * parameters, so there is no compile-time error. Enforcement is runtime-only.\n */\nexport const setDescription = (entity: Mutable<Unknown>, description: string): void =>\n  internal.setDescription(entity, description);\n\n/**\n * Symbol to set parent when creating objects with `Obj.make`.\n * @example\n * ```ts\n * Obj.make(TestSchema.Person, {\n *   [Obj.Parent]: parentObject,\n *   name: 'John',\n * })\n * ```\n */\nexport const Parent: unique symbol = internal.ParentId as any;\n\n/**\n * Get the parent of an object.\n * The parent is always loaded together with the object.\n * Only objects are allowed to have a parent\n * @returns The parent object, or undefined if the object has no parent.\n */\nexport const getParent = (entity: Unknown | Snapshot): Unknown | undefined => {\n  assertArgument(isObject(entity), 'Expected an object');\n  assumeType<internal.InternalObjectProps>(entity);\n  return entity[internal.ParentId] as Unknown | undefined;\n};\n\n/**\n * Sets the parent of an object.\n * If a parent (or any transitive parent) is deleted, the object will be deleted.\n * Only objects are allowed to have a parent.\n */\nexport const setParent = (entity: Unknown, parent: Any | undefined) => {\n  assertArgument(isObject(entity), 'Expected an object');\n  assertArgument(parent === undefined || isObject(parent), 'Expected an object');\n  assumeType<internal.InternalObjectProps>(entity);\n  assumeType<internal.InternalObjectProps | undefined>(parent);\n  entity[internal.ParentId] = parent;\n};\n\ninterface UpdateFromOptions<T> {\n  exclude?: (keyof T)[];\n  include?: (keyof T)[];\n}\n\nconst valuesEqual = (left: unknown, right: unknown): boolean => {\n  if (left === right) {\n    return true;\n  }\n  if (left === null || right === null) {\n    return left === right;\n  }\n  if (typeof left !== 'object' || typeof right !== 'object') {\n    return Utils.structuralRegion(() => Equal.equals(left, right));\n  }\n  if (Ref.isRef(left) && Ref.isRef(right)) {\n    return left.dxn.toString() === right.dxn.toString();\n  }\n  if (Ref.isRef(left) || Ref.isRef(right)) {\n    return false;\n  }\n  if (Array.isArray(left) && Array.isArray(right)) {\n    if (left.length !== right.length) {\n      return false;\n    }\n    for (let index = 0; index < left.length; index++) {\n      if (!valuesEqual(left[index], right[index])) {\n        return false;\n      }\n    }\n    return true;\n  }\n  if (Array.isArray(left) || Array.isArray(right)) {\n    return false;\n  }\n  const leftRecord = left as Record<string, unknown>;\n  const rightRecord = right as Record<string, unknown>;\n  const keys = new Set([\n    ...Object.keys(leftRecord).filter((key) => key !== 'id'),\n    ...Object.keys(rightRecord).filter((key) => key !== 'id'),\n  ]);\n  for (const key of keys) {\n    const leftHas = Object.hasOwn(leftRecord, key);\n    const rightHas = Object.hasOwn(rightRecord, key);\n    const leftValue = leftHas ? leftRecord[key] : undefined;\n    const rightValue = rightHas ? rightRecord[key] : undefined;\n    if (!valuesEqual(leftValue, rightValue)) {\n      return false;\n    }\n  }\n  return true;\n};\n\n/**\n * Breaks reactive proxies on assigned values so echo-db assignment accepts nested structs (same idea as link assignment).\n */\nconst prepareAssignValue = (value: unknown): unknown =>\n  deepMapValues(value, (nested, recurse) => {\n    if (nested === null || typeof nested !== 'object') {\n      return nested;\n    }\n    if (Ref.isRef(nested)) {\n      return nested;\n    }\n    if (Array.isArray(nested)) {\n      return recurse(nested);\n    }\n    if (isProxy(nested)) {\n      return recurse({ ...getProxyTarget(nested) });\n    }\n    return recurse(nested);\n  });\n\n/**\n * For each key present on `source` (except `id`), assigns `target[key]` when the current value differs.\n * References are compared by target DXN; other values use Effect `Equal.equals` inside a structural region,\n * with recursive comparison for arrays and plain object-shaped property bags (excluding `id`).\n *\n * Must be called within an `Obj.update` callback.\n *\n * @returns Whether any property was updated.\n */\nexport const updateFrom = <T extends Unknown>(\n  target: Mutable<T>,\n  source: T,\n  options?: UpdateFromOptions<T>,\n): boolean => {\n  assertArgument(isObject(target), 'Expected an echo object target.');\n  assertArgument(isObject(source), 'Expected an echo object source.');\n  let keys = Object.keys(source as Record<string, unknown>).filter((key) => key !== 'id');\n  if (options?.include !== undefined) {\n    const include = new Set(options.include.map((key) => String(key)));\n    keys = keys.filter((key) => include.has(key));\n  }\n  if (options?.exclude !== undefined) {\n    const exclude = new Set(options.exclude.map((key) => String(key)));\n    keys = keys.filter((key) => !exclude.has(key));\n  }\n  let updated = false;\n  const sourceRecord = source as Record<string, unknown>;\n  const targetRecord = target as Record<string, unknown>;\n  for (const key of keys) {\n    if (!Object.hasOwn(sourceRecord, key)) {\n      continue;\n    }\n    const nextValue = sourceRecord[key];\n    const prevValue = Object.hasOwn(targetRecord, key) ? targetRecord[key] : undefined;\n    if (valuesEqual(prevValue, nextValue)) {\n      continue;\n    }\n    targetRecord[key] = prepareAssignValue(nextValue) as never;\n    updated = true;\n  }\n  return updated;\n};\n\n//\n// JSON\n//\n\n/**\n * JSON representation of an object.\n */\nexport type JSON = internal.ObjectJSON;\n\n/**\n * Converts object to its JSON representation.\n * Accepts both reactive objects and snapshots.\n *\n * The same algorithm is used when calling the standard `JSON.stringify(obj)` function.\n */\nexport const toJSON = (entity: Unknown | Snapshot): JSON => objInternal.objectToJSON(entity);\n\n/**\n * Creates an object from its json representation, performing schema validation.\n * References and schemas will be resolvable if the `refResolver` is provided.\n *\n * The function must be async to support resolving the schema as well as the relation endpoints.\n *\n * @param options.refResolver - Resolver for references. Produces hydrated references that can be resolved.\n * @param options.dxn - Override object DXN. Changes the result of `Obj.getDXN`.\n * @param options.database - Database to associate with the object.\n */\nexport const fromJSON: (\n  json: unknown,\n  options?: { refResolver?: Ref.Resolver; dxn?: DXN; database?: Database.Database; parent?: Unknown },\n) => Promise<Unknown> = objInternal.objectFromJSON as any;\n\n/**\n * Comparator function type for sorting objects.\n * Accepts both reactive objects and snapshots.\n */\nexport type Comparator = internal.Comparator<Unknown | Snapshot>;\n\nexport const sortByLabel: Comparator = internal.sortByLabel as Comparator;\nexport const sortByTypename: Comparator = internal.sortByTypename as Comparator;\nexport const sort = (...comparators: Comparator[]): Comparator => internal.sort(...comparators) as Comparator;\n\n//\n// Version\n//\n\nexport const VersionTypeId = internal.VersionTypeId;\nexport type VersionCompareResult = internal.VersionCompareResult;\n\n/**\n * Represent object version.\n * May be backed by Automerge.\n * Objects with no history are not versioned.\n */\nexport type Version = internal.EntityVersion;\n\nexport const isVersion = internal.isVersion;\nexport const versionValid = internal.versionValid;\nexport const compareVersions = internal.compareVersions;\nexport const encodeVersion = internal.encodeVersion;\nexport const decodeVersion = internal.decodeVersion;\n\n/**\n * Returns the version of the object.\n * Accepts both reactive objects and snapshots.\n */\nexport const version = (entity: Unknown | Snapshot): Version => internal.version(entity);\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;iBAAAA;EAAA,qBAAAC;EAAA,cAAAC;EAAA,aAAAC;EAAA,uBAAAC;EAAA,qBAAAC;EAAA,kBAAAC;EAAA,qBAAAC;EAAA;gBAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,eAAAC;EAAA,gBAAAC;EAAA;;;;;mBAAAC;EAAA,mBAAAC;EAAA,kBAAAC;EAAA,mBAAAC;EAAA,gBAAAC;EAAA;mBAAAC;EAAA;;mBAAAC;EAAA;mBAAAC;EAAA,sBAAAC;EAAA,gBAAAC;EAAA;kBAAAC;EAAA;cAAAC;EAAA,mBAAAC;EAAA,sBAAAC;EAAA,iBAAAC;EAAA;;;iBAAAC;EAAA,oBAAAC;;AAMA,YAAYC,YAAY;AACxB,YAAYC,WAAW;AACvB,YAAYC,cAAc;AAC1B,YAAYC,YAAY;AACxB,YAAYC,YAAY;AACxB,YAAYC,WAAW;AAGvB,SAASC,sBAAsB;AAC/B,SAASC,gBAAgBC,iBAAiB;AAC1C,SAAmBC,gBAAgB;AACnC,SAASC,YAAYC,qBAAqB;AA+B1C,IAAA,eAAA;AA0BO,IACLC,WAAqBC,cAAO;EAAEC,IAAKF;;EAAsBA,cAAc,cAAA;IAAC,KACxE;IACA,OAAA;EACA,CAAA,CAAA;;;;EACoEG,iBAAkBC;IACtF,UACSC;aACKC;;EACZ,CAAA,WACF,OAAA,OAAA,QAAA;IAsCIC,CAAAA,YAAmC,GAAA,OAAA,YAAA;EACvCC,CAAAA;AAAAA;AACF,IAAA,cAAA;EAiBA,MAAA,CAAA;;AAyBMC,IAAwCC,OAAAA,CAAAA,QAAAA,UAAAA;AAE5C,iBAAA,kBAA0C,MAAA,GAAA,SAAA,KAAA,QAAA,UAAA,2BAAA;AAC1C,MAAIC,OAAMC;YACIC,MAAAA,KAAgBN,MAAAA;WAAiBI;MAAuB,GAAA,gBAAA,WAAA;MACpE,GAAOA,MAAeG,MAAM;IAC9B;AAEA,WAAA,MAAA,MAAA;EACA;AAGA,QAAK,kBAAaC,OAAOC,YAAAA,OAAsBL,QAAQ,KAAA,EAAA,OAAA,CAAA,CAAA,GAAA,CAAA,MAAA,MAAA,MAAA,CAAA;aAEjDM,OAAUP,OAAAA,sBAAW,KAAA,GAAA;UACvBQ,QAAAA,MAAgBC,GAAAA;AAClB,QAAA,UAAA,QAAA;AACF,sBAAA,GAAA,IAAA;IAEA;;SAES,WAAA,QAAA,iBAAA;IACT,GAAA;IACA,GAAA;EAEF,CAAA;;AAKS,IAAA,WAAe,CAAA,QAAA;AACtB,aAAA,GAAA;AAEF,SAAO,OAAMC,QAAa,YAACC,QAAAA,QAAAA,IAAAA,MAAAA,MAAAA,KAAAA;;AAEzB,IAAO,aAAe,CAAA,QAAA;AACtB,aAAA,GAAA;AAEF,SAAA,OAAA,QAAA,YAAA,QAAA,QAAA,IAAA,cAAA,MAAA,KAAA;;AAQE,IAAAC,aAAA,CAAA,KAAA,aAAA;AAEA,SAAA,UAAA,KAAA,QAAA;AACF;;AA8BI,IAAS,cAAA,CAAA,aAAA,WAAA,aAAA;QACP,KAAcC,YAAY,QAAQC;WAAmBC;WAAuBC,OAAYC,YAASC,IAAE,iBAAA;MAAC,QAAA;MACtG,YAAA,SAAA;IACA,CAAA,CAAMP;EACN;QACE,MAAO,GAAA,cAAkB,SAASG,EAAAA;YAAmBC;WAA4BC,OAAYC,YAASC,IAAE,iBAAA;MAAC,QAAA;MAC3G,YAAA,SAAA;IACA,CAAA,CAAA;EACC;AAEL,SAAA;;;;;AAuFE,IAAA,SAAA,CAAA,KAAA,aAAA;AAEF,EAAA,OAAA,KAAA,QAAA;;AAwBE,IAAAC,YAAA,CAAA,KAAA,SAAA;AAEF,SAAA,SAAA,KAAA,eAAA,IAAA,CAAA;;AA8BO,IAAAC,YAAA;;AAuBH,IAAQC,aAAoBnB,IAASoB,SAAAA;AACvC,MAAA,KAAA,WAAA,GAAA;AAEA,WAAOpB,CAAAA,WAAsBqB,aAAc,KAAE,CAAA,GAAA,MAAA;EACrC;AAEV,SAAA,aAAA,KAAA,CAAA,GAAA,KAAA,CAAA,CAAA;;AAuBMA,IAAKC,aAAc,IAAA,SAAA;QACrB,QAAQH,CAAAA,WAAoBI,UAAMJ,QAAAA,OAAAA,WAAAA,YAAAA,kBAAAA,UAAAA,aAAAA,KAAAA,CAAAA,GAAAA,MAAAA;AACpC,MAAA,KAAA,WAAA,GAAA;AAEA,WAAOI,CAAAA,WAAa,MAAA,MAAA;EACZ;AAEV,SAAA,MAAA,KAAA,CAAA,CAAA;AACA;AAMSvB,IAAAA,UAAe,CAACmB,WAAAA;AACvB,iBAAA,CAAA,gBAAA,MAAA,GAAA,OAAA,gCAAA;AAEF,SAAA,OAAA,MAAA;;AAOEK,IAAUC,cAAc,CAAA,QAAA;AACxB,QAAA,OAAOA,WAAAA,GAAAA;AACP,YAAA,QAAA,MAAA,mCAAA,EAAA,YAAA,YAAA,GAAA,cAAA,GAAA,KAAA,GAAA,QAAA,GAAA,CAAA,gBAAA,mCAAA,EAAA,CAAA;AAEF,SAAA;;;AAcW,IAAAC,eAAA,CAAA,WAAA,YAAA,MAAA;AAWJ,IAAAC,eAAA,CAAA,WAAA,YAAA,MAAA;AA6CE3B,IAAAA,OAAS4B;AAClB,SAAA,QAAA,QAAA;AAEA,SAAA,eAAA,MAAA;;;;;;AA4CA,IAAAC,aAAc,CAAA,WAAA,UAAA,MAAA;;;;;;AAsDZC,IAAyCX,YAAAA,CAAAA,WAAAA;AACzC,iBAAcnB,SAAS+B,MAAAA,GAAS,oBAAA;AAChC,aAAA,MAAA;AAEF,SAAA,OAAA,QAAA;;AAOEC,IAAAA,YAAeC,CAAWnC,QAAAA,WAAaoC;AACvCJ,iBAAyCX,SAAAA,MAAAA,GAAAA,oBAAAA;AACzCW,iBAAqDG,WAAAA,UAAAA,SAAAA,MAAAA,GAAAA,oBAAAA;AACrDd,aAAOnB,MAAS+B;AAChB,aAAA,MAAA;AAOF,SAAoB,QAAgBI,IAAAA;;kBAEzB,CAAA,MAAA,UAAA;AACT,MAAA,SAAA,OAAA;AACIC,WAAAA;;AAEJ,MAAA,SAAA,QAAA,UAAA,MAAA;AACI,WAAOA,SAAS;;AAEpB,MAAA,OAAA,SAAA,YAAA,OAAA,UAAA,UAAA;AACIC,WAAUD,uBAAmBD,MAAQ,aAAA,MAAA,KAAA,CAAA;;AAEzC,MAAA,MAAA,IAAA,KAAA,MAAA,KAAA,GAAA;AACIE,WAAIC,KAAMF,IAAAA,SAAaE,MAAMH,MAAQ,IAAA,SAAA;;AAEzC,MAAA,MAAA,IAAA,KAAA,MAAA,KAAA,GAAA;AACII,WAAMC;;YAEN,QAAO,IAAA,KAAA,MAAA,QAAA,KAAA,GAAA;AACT,QAAA,KAAA,WAAA,MAAA,QAAA;AACK,aAAIC;;aAEL,QAAO,GAAA,QAAA,KAAA,QAAA,SAAA;AACT,UAAA,CAAA,YAAA,KAAA,KAAA,GAAA,MAAA,KAAA,CAAA,GAAA;AACF,eAAA;MACA;IACF;AACIF,WAAMC;;AAEV,MAAA,MAAA,QAAA,IAAA,KAAA,MAAA,QAAA,KAAA,GAAA;AACA,WAAME;EACN;AACA,QAAM9C,aAAW+C;sBACAD;eACZvC,oBAAOP,IAAKgD;IAChB,GAAA,OAAA,KAAA,UAAA,EAAA,OAAA,CAAA,QAAA,QAAA,IAAA;IACD,GAAK,OAAMtD,KAAOM,WAAM,EAAA,OAAA,CAAA,QAAA,QAAA,IAAA;;aAEhBiD,OAAAA,MAAW1C;AACjB,UAAM2C,UAAAA,OAAYC,OAAUL,YAAWpD,GAAI;AAC3C,UAAM0D,WAAAA,OAAaH,OAAWD,aAAYtD,GAAI;AAC9C,UAAK2D,YAAYH,UAAWE,WAAAA,GAAa,IAAA;UACvC,aAAO,WAAA,YAAA,GAAA,IAAA;AACT,QAAA,CAAA,YAAA,WAAA,UAAA,GAAA;AACF,aAAA;IACA;EACF;AAEA,SAAA;;yBAMaE,CAAAA,UAAAA,cAAAA,OAAAA,CAAAA,QAAAA,YAAAA;AACT,MAAA,WAAA,QAAA,OAAA,WAAA,UAAA;AACIb,WAAIC;;AAER,MAAA,MAAA,MAAA,GAAA;AACIC,WAAMC;;AAEV,MAAA,MAAA,QAAA,MAAA,GAAA;AACIW,WAAAA,QAAQD,MAAS;;cACCE,MAAAA,GAAAA;AAAuB,WAAA,QAAA;MAC7C,GAAA,eAAA,MAAA;IACA,CAAA;EACF;AAEF,SAAA,QAAA,MAAA;;AAeEpB,IAAAA,aAAwBqB,CAAAA,QAAS,QAAA,YAAA;AACjC,iBAAWlD,SAAYkD,MAAAA,GAAmCC,iCAAwB;AAClF,iBAAaC,SAAAA,MAAYzD,GAAAA,iCAAW;MAClC,OAAMyD,OAAAA,KAAU,MAAQC,EAAAA,OAAQD,CAAAA,QAAQE,QAAKnE,IAAQoE;MACrD9D,SAAOA,YAAaN,QAAQiE;AAC9B,UAAA,UAAA,IAAA,IAAA,QAAA,QAAA,IAAA,CAAA,QAAA,OAAA,GAAA,CAAA,CAAA;AACIC,WAAAA,KAASG,OAAAA,CAAAA,QAAY7D,QAAW,IAAA,GAAA,CAAA;;MAElCF,SAAOA,YAAaN,QAASqE;AAC/B,UAAA,UAAA,IAAA,IAAA,QAAA,QAAA,IAAA,CAAA,QAAA,OAAA,GAAA,CAAA,CAAA;AACIC,WAAAA,KAAU,OAAA,CAAA,QAAA,CAAA,QAAA,IAAA,GAAA,CAAA;EACd;AACA,MAAA,UAAMC;AACN,QAAK,eAAajE;QAChB,eAAYkE;aACV,OAAA,MAAA;AACF,QAAA,CAAA,OAAA,OAAA,cAAA,GAAA,GAAA;AACA;IACA;AACA,UAAIb,YAAYc,aAAWC,GAAAA;UACzB,YAAA,OAAA,OAAA,cAAA,GAAA,IAAA,aAAA,GAAA,IAAA;AACF,QAAA,YAAA,WAAA,SAAA,GAAA;AACAH;IACAD;AACF,iBAAA,GAAA,IAAA,mBAAA,SAAA;AACA,cAAOA;EACP;AAWF,SAAA;;;AA8BO,IAAMK,WAAsCA;AAC5C,IAAMC,eAAWC;AAEtB,IAAAF,kBAAA;AACF,IAAUC,QAAA,IAAA,gBAAA,KAAA,GAAA,WAAA;AAcH,IAAME,iBAAwBA;AAC9B,IAAMC,aAAkBrE;AACxB,IAAMsE,gBAAgBtE;AACtB,IAAMuE,mBAAyBA;AAEtC,IAAAD,iBAAA;;;",
+  "names": ["Unknown", "VersionTypeId", "addTag", "clone", "compareVersions", "decodeVersion", "deleteKeys", "encodeVersion", "getDXN", "getDatabase", "getDescription", "getKeys", "getLabel", "getSchema", "getSnapshot", "getTypeDXN", "getTypename", "getValue", "isDeleted", "isVersion", "removeTag", "setDescription", "setLabel", "setValue", "sort", "sortByLabel", "sortByTypename", "subscribe", "version", "versionValid", "Effect", "Equal", "Function", "Option", "Schema", "Utils", "createJsonPath", "assertArgument", "invariant", "ObjectId", "assumeType", "deepMapValues", "Schema", "Record", "key", "version", "ANY_OBJECT_VERSION", "assign", "SchemaKindId", "defaultMeta", "keys", "meta", "undefined", "props", "internal", "structuredClone", "MetaId", "Object", "getOwnPropertySymbols", "value", "filterUndefined", "sym", "isSnapshot", "obj", "subscribe", "Effect", "GetReactiveError", "reason", "snapshotId", "snapshot", "id", "getValue", "setValue", "entity", "isInstanceOf", "args", "length", "check", "invariant", "type", "getTypename", "getDatabase", "getMetaChecked", "isDeleted", "assumeType", "ParentId", "assertArgument", "parent", "isObject", "right", "left", "Ref", "isRef", "Array", "isArray", "index", "leftRecord", "Set", "rightRecord", "rightHas", "leftValue", "leftHas", "rightValue", "valuesEqual", "nested", "isProxy", "getProxyTarget", "source", "filter", "include", "options", "map", "String", "exclude", "updated", "targetRecord", "hasOwn", "prevValue", "nextValue", "sortByTypename", "sort", "comparators", "versionValid", "compareVersions", "encodeVersion", "decodeVersion"]
+}

package/dist/lib/neutral/chunk-FIWO2FZK.mjs

@@ -0,0 +1,36 @@
+import {
+  getSchemaDXN
+} from "./chunk-TNBK56IN.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Migration.ts
+var Migration_exports = {};
+__export(Migration_exports, {
+  define: () => define
+});
+var define = (options) => {
+  const fromType = getSchemaDXN(options.from);
+  if (!fromType) {
+    throw new Error("Invalid from schema");
+  }
+  const toType = getSchemaDXN(options.to);
+  if (!toType) {
+    throw new Error("Invalid to schema");
+  }
+  return {
+    fromType,
+    toType,
+    fromSchema: options.from,
+    toSchema: options.to,
+    transform: options.transform,
+    onMigration: options.onMigration
+  };
+};
+
+export {
+  define,
+  Migration_exports
+};
+//# sourceMappingURL=chunk-FIWO2FZK.mjs.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/Migration.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\n// @import-as-namespace\n\nimport type * as Schema from 'effect/Schema';\n\nimport { type DXN } from '@dxos/keys';\n\nimport type * as Database from './Database';\nimport type * as Entity from './Entity';\nimport { MetaId, type ObjectMeta, getSchemaDXN } from './internal';\n\n/**\n * Result returned by a migration's `transform` callback.\n * The data shape matches the target schema; the optional `[Obj.Meta]` symbol key lets the\n * transform update the object's meta (e.g. `key` / `version`) atomically with the data swap.\n */\nexport type TransformResult<To extends Schema.Schema.AnyNoContext> = Omit<\n  Schema.Schema.Type<To>,\n  'id' | Entity.KindId\n> & {\n  [MetaId]?: Partial<ObjectMeta>;\n};\n\ntype DefineObjectMigrationOptions<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {\n  from: From;\n  to: To;\n  /**\n   * Pure function that converts the old object data to the new object data.\n   *\n   * The returned object may include an optional `[Obj.Meta]` entry to update the object's meta\n   * (e.g. registry `key` / `version`) atomically with the data swap.\n   */\n  // TODO(dmaretskyi): `id` should not be a part of the schema.\n  transform: (from: Schema.Schema.Type<From>, context: ObjectMigrationContext) => Promise<TransformResult<To>>;\n\n  /**\n   * Callback that is called after the object is migrated. Called for every object that is migrated.\n   *\n   * NOTE: Database mutations performed in this callback are not guaranteed to be idempotent.\n   *       If multiple peers run the migration separately, the effects may be applied multiple times.\n   */\n  onMigration?: (params: OnMigrateProps<From, To>) => Promise<void>;\n};\n\n/**\n * Context passed to object migration callbacks.\n */\nexport type ObjectMigrationContext = {\n  db: Database.Database;\n};\n\ntype OnMigrateProps<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {\n  before: Schema.Schema.Type<From>;\n  object: Schema.Schema.Type<To>;\n  db: Database.Database;\n};\n\n/**\n * Definition of a migration from one object schema version to another.\n */\nexport type ObjectMigration = {\n  fromType: DXN;\n  toType: DXN;\n  fromSchema: Schema.Schema.AnyNoContext;\n  toSchema: Schema.Schema.AnyNoContext;\n  transform: (from: unknown, context: ObjectMigrationContext) => Promise<unknown>;\n  onMigration?: (params: OnMigrateProps<any, any>) => Promise<void>;\n};\n\n/**\n * Define a migration between two object schemas.\n *\n * @example\n * ```ts\n * const migration = Migration.define({\n *   from: ContactV1,\n *   to: ContactV2,\n *   transform: async (from) => ({ name: `${from.firstName} ${from.lastName}` }),\n *   onMigration: async () => {},\n * });\n * ```\n */\nexport const define = <From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext>(\n  options: DefineObjectMigrationOptions<From, To>,\n): ObjectMigration => {\n  const fromType = getSchemaDXN(options.from);\n  if (!fromType) {\n    throw new Error('Invalid from schema');\n  }\n  const toType = getSchemaDXN(options.to);\n  if (!toType) {\n    throw new Error('Invalid to schema');\n  }\n\n  return {\n    fromType,\n    toType,\n    fromSchema: options.from,\n    toSchema: options.to,\n    transform: options.transform as any,\n    onMigration: options.onMigration as any,\n  };\n};\n"],
+  "mappings": ";;;;;;;;AAAA;;;;AAqFO,IAAMA,SAAS,CACpBC,YAAAA;AAEA,QAAMC,WAAWC,aAAaF,QAAQG,IAAI;AAC1C,MAAI,CAACF,UAAU;AACb,UAAM,IAAIG,MAAM,qBAAA;EAClB;AACA,QAAMC,SAASH,aAAaF,QAAQM,EAAE;AACtC,MAAI,CAACD,QAAQ;AACX,UAAM,IAAID,MAAM,mBAAA;EAClB;AAEA,SAAO;IACLH;IACAI;IACAE,YAAYP,QAAQG;IACpBK,UAAUR,QAAQM;IAClBG,WAAWT,QAAQS;IACnBC,aAAaV,QAAQU;EACvB;AACF;",
+  "names": ["define", "options", "fromType", "getSchemaDXN", "from", "Error", "toType", "to", "fromSchema", "toSchema", "transform", "onMigration"]
+}