@dxos/echo 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/internal/common/types/entity.ts

@@ -41,13 +41,21 @@ export type SnapshotKindId = typeof SnapshotKindId;
 export const StaticTypeSchemaSlot = '~@dxos/echo/Type.StaticSchema' as const;
 export type StaticTypeSchemaSlot = typeof StaticTypeSchemaSlot;
 
+/**
+ * Whether a value can carry an entity brand/slot. Class-declared types
+ * Class-declared types (`Type.makeObject`) are functions whose prototype chain reaches the entity,
+ * so brand/slot lookups must accept functions as well as plain objects.
+ */
+const isBrandCarrier = (value: unknown): boolean =>
+  value != null && (typeof value === 'object' || typeof value === 'function');
+
 /**
  * Read the hidden `StaticTypeSchemaSlot` off any value that may carry one.
- * Returns `undefined` for raw schemas (no slot) and non-object inputs.
+ * Returns `undefined` for raw schemas (no slot) and inputs that cannot carry a brand.
  * Single point-of-cast for the slot lookup.
  */
 export const getStaticTypeSchema = (value: unknown): Schema.Schema.AnyNoContext | undefined => {
-  if (value == null || typeof value !== 'object') {
+  if (!isBrandCarrier(value)) {
     return undefined;
   }
   return (value as { [StaticTypeSchemaSlot]?: Schema.Schema.AnyNoContext })[StaticTypeSchemaSlot];
@@ -55,11 +63,11 @@ export const getStaticTypeSchema = (value: unknown): Schema.Schema.AnyNoContext
 
 /**
  * Read the `[SchemaKindId]` brand off a value. Returns `undefined` for raw
- * schemas (which don't carry the brand on their static type) and non-object
- * inputs. Single point-of-cast for the brand lookup.
+ * schemas (which don't carry the brand on their static type) and inputs that
+ * cannot carry a brand. Single point-of-cast for the brand lookup.
  */
 export const getSchemaKind = (value: unknown): EntityKind | undefined => {
-  if (value == null || typeof value !== 'object') {
+  if (!isBrandCarrier(value)) {
     return undefined;
   }
   return (value as { [SchemaKindId]?: EntityKind })[SchemaKindId];
@@ -67,10 +75,10 @@ export const getSchemaKind = (value: unknown): EntityKind | undefined => {
 
 /**
  * Read the `[KindId]` brand off a value. Returns `undefined` for raw schemas
- * and non-object inputs. Companion to {@link getSchemaKind}.
+ * and inputs that cannot carry a brand. Companion to {@link getSchemaKind}.
  */
 export const getEntityKindBrand = (value: unknown): EntityKind | undefined => {
-  if (value == null || typeof value !== 'object') {
+  if (!isBrandCarrier(value)) {
     return undefined;
   }
   return (value as { [KindId]?: EntityKind })[KindId];

package/src/internal/index.ts

@@ -5,6 +5,7 @@
 export * from './Annotation';
 export * from './common';
 export * from './Entity';
+export * from './Filter';
 export * from './Format';
 export * from './JsonSchema';
 // TODO(wittjosiah): Required to ensure types are portable (need to export all types required for downstream inference).

package/src/testing/test-schema.ts

@@ -19,11 +19,9 @@ export namespace TestSchema {
    * Expando object is an object with an arbitrary set of properties.
    * This is the test variant with example.com namespace.
    */
-  export const Expando = Schema.Struct({}, { key: Schema.String, value: Schema.Any }).pipe(
-    Type.makeObject(DXN.make('com.example.type.expando', '0.1.0')),
-  );
-
-  export type Expando = Type.InstanceType<typeof Expando>;
+  export class Expando extends Type.makeObject<Expando>(DXN.make('com.example.type.expando', '0.1.0'))(
+    Schema.Struct({}, { key: Schema.String, value: Schema.Any }),
+  ) {}
 
   //
   // Example
@@ -62,10 +60,7 @@ export namespace TestSchema {
   export interface ExampleSchema extends Schema.Schema.Type<typeof ExampleSchema> {}
 
   /** @deprecated Use another test schema or create a specific local test schema. */
-  export const Example = ExampleSchema.pipe(Type.makeObject(DXN.make('com.example.type.example', '0.1.0')));
-
-  /** @deprecated Use another test schema or create a specific local test schema. */
-  export interface Example extends Type.InstanceType<typeof Example> {}
+  export class Example extends Type.makeObject<Example>(DXN.make('com.example.type.example', '0.1.0'))(ExampleSchema) {}
 
   //
   // Message
@@ -81,100 +76,90 @@ export namespace TestSchema {
     ),
   });
 
-  export const Message = MessageStruct.pipe(Type.makeObject(DXN.make('com.example.type.message', '0.1.0')));
-
-  export type Message = Type.InstanceType<typeof Message>;
+  export class Message extends Type.makeObject<Message>(DXN.make('com.example.type.message', '0.1.0'))(MessageStruct) {}
 
   //
   // Organization
   //
 
-  export const Organization = Schema.Struct({
-    name: Schema.String,
-    properties: Schema.optional(
-      Schema.Record({
-        key: Schema.String,
-        value: Schema.String,
-      }),
-    ),
-  }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
-
-  export type Organization = Type.InstanceType<typeof Organization>;
+  export class Organization extends Type.makeObject<Organization>(DXN.make('com.example.type.organization', '0.1.0'))(
+    Schema.Struct({
+      name: Schema.String,
+      properties: Schema.optional(
+        Schema.Record({
+          key: Schema.String,
+          value: Schema.String,
+        }),
+      ),
+    }),
+  ) {}
 
   //
   // Person
   //
 
-  export const Person = Schema.Struct({
-    name: Schema.String,
-    username: Schema.String,
-    email: Schema.String,
-    age: Schema.Number.pipe(Schema.optional),
-    tasks: Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
-    employer: Schema.optional(Ref.Ref(Organization)),
-    address: Schema.Struct({
-      city: Schema.optional(Schema.String),
-      state: Schema.optional(Schema.String),
-      zip: Schema.optional(Schema.String),
-      coordinates: Schema.Struct({
-        lat: Schema.optional(Schema.Number),
-        lng: Schema.optional(Schema.Number),
+  export class Person extends Type.makeObject<Person>(DXN.make('com.example.type.person', '0.1.0'))(
+    Schema.Struct({
+      name: Schema.String,
+      username: Schema.String,
+      email: Schema.String,
+      age: Schema.Number.pipe(Schema.optional),
+      tasks: Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
+      employer: Schema.optional(Ref.Ref(Organization)),
+      address: Schema.Struct({
+        city: Schema.optional(Schema.String),
+        state: Schema.optional(Schema.String),
+        zip: Schema.optional(Schema.String),
+        coordinates: Schema.Struct({
+          lat: Schema.optional(Schema.Number),
+          lng: Schema.optional(Schema.Number),
+        }),
       }),
-    }),
-    fields: Schema.Struct({
-      label: Schema.String,
-      value: Schema.String,
-    }).pipe(Schema.Array, Schema.optional),
-  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
-
-  export interface Person extends Type.InstanceType<typeof Person> {}
+      fields: Schema.Struct({
+        label: Schema.String,
+        value: Schema.String,
+      }).pipe(Schema.Array, Schema.optional),
+    }).pipe(Schema.partial),
+  ) {}
 
   //
   // Task
   //
 
-  export const Task = Schema.Struct({
-    title: Schema.optional(Schema.String),
-    deadline: Schema.optional(Schema.String),
-    completed: Schema.optional(Schema.Boolean),
-    assignee: Schema.optional(Ref.Ref(Person)),
-    previous: Schema.optional(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
-    subTasks: Schema.optional(Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task)))),
-    description: Schema.optional(Schema.String),
-  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.task', '0.1.0')));
-
-  export interface Task extends Type.InstanceType<typeof Task> {}
+  export class Task extends Type.makeObject<Task>(DXN.make('com.example.type.task', '0.1.0'))(
+    Schema.Struct({
+      title: Schema.optional(Schema.String),
+      deadline: Schema.optional(Schema.String),
+      completed: Schema.optional(Schema.Boolean),
+      assignee: Schema.optional(Ref.Ref(Person)),
+      previous: Schema.optional(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task))),
+      subTasks: Schema.optional(Schema.Array(Schema.suspend((): Ref.RefSchema<Task> => Ref.Ref(Task)))),
+      description: Schema.optional(Schema.String),
+    }).pipe(Schema.partial),
+  ) {}
 
   //
   // HasManager
   //
 
-  export const HasManager = Schema.Struct({}).pipe(
-    Type.makeRelation({
-      dxn: DXN.make('com.example.type.hasManager', '0.1.0'),
-      source: Person,
-      target: Person,
-    }),
-  );
-
-  export type HasManager = Type.InstanceType<typeof HasManager>;
+  export class HasManager extends Type.makeRelation<HasManager>(DXN.make('com.example.type.hasManager', '0.1.0'))({
+    source: Person,
+    target: Person,
+  })(Schema.Struct({})) {}
 
   //
   // EmployedBy
   //
 
-  export const EmployedBy = Schema.Struct({
-    role: Schema.String,
-    since: Schema.optional(Schema.String),
-  }).pipe(
-    Type.makeRelation({
-      dxn: DXN.make('com.example.type.employedBy', '0.1.0'),
-      source: Person,
-      target: Organization,
+  export class EmployedBy extends Type.makeRelation<EmployedBy>(DXN.make('com.example.type.employedBy', '0.1.0'))({
+    source: Person,
+    target: Organization,
+  })(
+    Schema.Struct({
+      role: Schema.String,
+      since: Schema.optional(Schema.String),
     }),
-  );
-
-  export type EmployedBy = Type.InstanceType<typeof EmployedBy>;
+  ) {}
 
   //
   // RecordType
@@ -186,19 +171,19 @@ export namespace TestSchema {
     WORK = 2,
   }
 
-  export const Container = Schema.Struct({
-    objects: Schema.Array(Ref.Ref(Obj.Unknown)),
-    records: Schema.Array(
-      Schema.partial(
-        Schema.Struct({
-          title: Schema.String,
-          description: Schema.String,
-          contacts: Schema.Array(Ref.Ref(Person)),
-          type: Schema.Enums(RecordType),
-        }),
+  export class Container extends Type.makeObject<Container>(DXN.make('com.example.type.container', '0.1.0'))(
+    Schema.Struct({
+      objects: Schema.Array(Ref.Ref(Obj.Unknown)),
+      records: Schema.Array(
+        Schema.partial(
+          Schema.Struct({
+            title: Schema.String,
+            description: Schema.String,
+            contacts: Schema.Array(Ref.Ref(Person)),
+            type: Schema.Enums(RecordType),
+          }),
+        ),
       ),
-    ),
-  }).pipe(Schema.partial, Type.makeObject(DXN.make('com.example.type.container', '0.1.0')));
-
-  export type Container = Type.InstanceType<typeof Container>;
+    }).pipe(Schema.partial),
+  ) {}
 }

package/dist/lib/neutral/chunk-35INCYOE.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/QueryResult.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\nimport type * as Atom from '@effect-atom/atom/Atom';\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\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  /**\n   * Self-updating atom. Updates automatically when query results change.\n   *\n   * Memoized per QueryResult instance — repeated accesses on the same instance return the same\n   * Atom. Safe only when the QueryResult is itself held stable across re-renders (e.g. behind a\n   * `useMemo`). It must NOT be used in graph-builder connectors/actions or other atom computes,\n   * where `db.query(...)` is called fresh on each re-evaluation: every run constructs a new\n   * QueryResult and so a new atom + subscription, leaking the previous ones. Use the memoized\n   * {@link atom} family there instead.\n   */\n  readonly atom: Atom.Atom<T[]>;\n}\n\n/**\n * Effect that returns a QueryResult when evaluated, but also has shorthand methods for running the query or getting the first result.\n */\nexport interface QueryResultEffect<T, E, R> extends Effect.Effect<QueryResult<T>, E, R> {\n  run: Effect.Effect<T[], E, R>;\n  first: Effect.Effect<Option.Option<T>, E, R>;\n\n  // TODO(dmaretskyi): Considering adding `atom`, but since `Database.query` is used in imperative code only, I dont think it will be useful.\n}\n"],
-  "mappings": ";AAAA;",
-  "names": []
-}

package/dist/lib/neutral/chunk-3PBP4V4O.mjs

@@ -1,101 +0,0 @@
-import {
-  get,
-  set
-} from "./chunk-4ZUHOTCG.mjs";
-import {
-  DescriptionAnnotation,
-  Dictionary,
-  FieldLookupAnnotationId,
-  FormInlineAnnotation,
-  FormInputAnnotation,
-  GeneratorAnnotation,
-  GeneratorAnnotationId,
-  HiddenAnnotation,
-  IconAnnotation,
-  IconFromRefAnnotation,
-  Key,
-  LabelAnnotation,
-  ReferenceAnnotation,
-  ReferenceAnnotationId,
-  TypeAnnotation,
-  getDescriptionWithSchema,
-  getDictionary,
-  getFromAst,
-  getLabelWithSchema,
-  getTypeAnnotation,
-  getTypeIdentifierAnnotation,
-  makeUserAnnotation,
-  setDescriptionWithSchema,
-  setDictionary,
-  setLabelWithSchema
-} from "./chunk-R5W6DXR4.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Annotation.ts
-var Annotation_exports = {};
-__export(Annotation_exports, {
-  DescriptionAnnotation: () => DescriptionAnnotation,
-  Dictionary: () => Dictionary2,
-  FieldLookupAnnotationId: () => FieldLookupAnnotationId,
-  FormInlineAnnotation: () => FormInlineAnnotation,
-  FormInputAnnotation: () => FormInputAnnotation,
-  GeneratorAnnotation: () => GeneratorAnnotation,
-  GeneratorAnnotationId: () => GeneratorAnnotationId,
-  HiddenAnnotation: () => HiddenAnnotation,
-  IconAnnotation: () => IconAnnotation,
-  IconFromRefAnnotation: () => IconFromRefAnnotation,
-  Key: () => Key2,
-  LabelAnnotation: () => LabelAnnotation,
-  ReferenceAnnotation: () => ReferenceAnnotation,
-  ReferenceAnnotationId: () => ReferenceAnnotationId,
-  TypeAnnotation: () => TypeAnnotation,
-  TypeId: () => TypeId,
-  get: () => get2,
-  getDescriptionWithSchema: () => getDescriptionWithSchema,
-  getDictionary: () => getDictionary2,
-  getFromAst: () => getFromAst2,
-  getLabelWithSchema: () => getLabelWithSchema,
-  getTypeAnnotation: () => getTypeAnnotation,
-  getTypeIdentifierAnnotation: () => getTypeIdentifierAnnotation,
-  make: () => make,
-  set: () => set2,
-  setDescriptionWithSchema: () => setDescriptionWithSchema,
-  setDictionary: () => setDictionary2,
-  setLabelWithSchema: () => setLabelWithSchema
-});
-import * as Function from "effect/Function";
-var TypeId = "~@dxos/echo/Annotation";
-var Key2 = Key;
-var make = makeUserAnnotation;
-var get2 = Function.dual(2, (target, annotation) => {
-  return get(target, annotation);
-});
-var set2 = Function.dual(3, (target, annotation, value) => {
-  return set(target, annotation, value);
-});
-var getFromAst2 = Function.dual(2, (ast, annotation) => {
-  return getFromAst(ast, annotation);
-});
-var Dictionary2 = Dictionary;
-var getDictionary2 = Function.dual(2, (values, annotation) => {
-  return getDictionary(values, annotation);
-});
-var setDictionary2 = Function.dual(3, (values, annotation, value) => {
-  return setDictionary(values, annotation, value);
-});
-
-export {
-  TypeId,
-  Key2 as Key,
-  make,
-  get2 as get,
-  set2 as set,
-  getFromAst2 as getFromAst,
-  Dictionary2 as Dictionary,
-  getDictionary2 as getDictionary,
-  setDictionary2 as setDictionary,
-  Annotation_exports
-};
-//# sourceMappingURL=chunk-3PBP4V4O.mjs.map

package/dist/lib/neutral/chunk-3PBP4V4O.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/Annotation.ts"],
-  "sourcesContent": ["//\n// Copyright 2025 DXOS.org\n//\n\n// @import-as-namespace\n\nexport {\n  DescriptionAnnotation,\n  FieldLookupAnnotationId,\n  FormInputAnnotation,\n  FormInlineAnnotation,\n  GeneratorAnnotation,\n  GeneratorAnnotationId,\n  type GeneratorAnnotationValue,\n  LabelAnnotation,\n  ReferenceAnnotation,\n  ReferenceAnnotationId,\n  type ReferenceAnnotationValue,\n  HiddenAnnotation,\n  TypeAnnotation,\n  getDescriptionWithSchema,\n  getLabelWithSchema,\n  getTypeAnnotation,\n  getTypeIdentifierAnnotation,\n  setDescriptionWithSchema,\n  setLabelWithSchema,\n  IconAnnotation,\n  IconFromRefAnnotation,\n} from './internal/Annotation';\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';\nimport * as Types from 'effect/Types';\n\nimport * as Entity from './Entity';\nimport * as internalAnnotations from './internal/Annotation';\n\nexport const TypeId = '~@dxos/echo/Annotation' as const;\nexport type TypeId = typeof TypeId;\n\n// TODO(dmaretskyi): Reconcile different get/set styles: mutate in-place, return.\n// TODO(dmaretskyi): Reconcile Annotation methods vs static functions.\n// TODO(dmaretskyi): Reconcile Annotation.Key vs DXN -- work-out approach to versioning.\n\n/**\n * Annotation is a typed property that can be assigned to a schema or an entity instance.\n */\nexport interface Annotation<T> {\n  [TypeId]: {\n    _Type: T;\n  };\n\n  // TODO(dmaretskyi): Make this a DXN?\n  /**\n   * Unique fully-qualified identifier for the annotation.\n   * @example \"org.dxos.annotation.color\"\n   */\n  readonly key: Key;\n\n  /**\n   * Schema of the annotation value.\n   */\n  readonly schema: Schema.Schema<T, unknown, never>;\n\n  /**\n   * Get the annotation value from an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — to read an annotation off a `Type.Type`\n   * entity, unwrap it first with `Type.getSchema(entity)`. This keeps the\n   * annotation pipeline single-shaped and forces annotations to live on the\n   * source schema, not on the post-construction Type entity.\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 on an Effect schema.\n   *\n   * Only accepts `Schema.Schema.Any` — annotations must be applied to the\n   * source schema BEFORE wrapping it with `Type.makeObject` / `Type.makeRelation`.\n   * In a pipe, place every `Annotation.X.set(...)` before the `Type.make...` step.\n   */\n  set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;\n}\n\nexport const Key = internalAnnotations.Key;\nexport type Key = Schema.Schema.Type<typeof Key>;\n\ninterface MakeProps<T> {\n  id: string;\n  schema: Schema.Schema<T, any, never>;\n}\n\n/**\n * Create a new schema annotation.\n * Annotation can be assigned both to fields and to the schema itself.\n * Annotation is serialized with the schema.\n *\n * @example\n * ```ts\n * const ColorAnnotation = Annotation.make({\n *   id: 'org.dxos.annotation.color',\n *   schema: Schema.String,\n * });\n *\n * const schema = Schema.String.annotations(ColorAnnotation.set('red'));\n * ```\n */\nexport const make: <T>(props: MakeProps<T>) => Annotation<T> = internalAnnotations.makeUserAnnotation;\n\n/**\n * Get the value of an annotation from an entity instance or snapshot.\n * For schema-level reads use the annotation instance method (e.g. `ColorAnnotation.get(schema)`).\n * For getting an annotation value from a dictionary, use `getDictionary`.\n */\nexport const get: {\n  <T>(annotation: Annotation<T>): (target: Entity.Unknown | Entity.Snapshot) => Option.Option<T>;\n  <T>(target: Entity.Unknown | Entity.Snapshot, annotation: Annotation<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(annotation: Annotation<T>) => (target: Entity.Unknown | Entity.Snapshot) => Option.Option<T>,\n  <T>(target: Entity.Unknown | Entity.Snapshot, annotation: Annotation<T>) => Option.Option<T>\n>(2, (target, annotation) => {\n  return internalAnnotations.get(target, annotation);\n});\n\n/**\n * Set the value of an annotation on an entity instance.\n * For schema-level writes use the annotation instance method (e.g. `ColorAnnotation.set('red')`).\n * For setting an annotation value on a dictionary, use `setDictionary`.\n */\nexport const set: {\n  <T>(annotation: Annotation<T>, value: T): (target: Entity.Mutable<Entity.Unknown>) => void;\n  <T>(target: Entity.Mutable<Entity.Unknown>, annotation: Annotation<T>, value: T): void;\n} = Function.dual<\n  <T>(annotation: Annotation<T>, value: T) => (target: Entity.Mutable<Entity.Unknown>) => void,\n  <T>(target: Entity.Mutable<Entity.Unknown>, annotation: Annotation<T>, value: T) => void\n>(3, (target, annotation, value) => {\n  return internalAnnotations.set(target, annotation, value);\n});\n\nexport const getFromAst: {\n  <T>(annotation: Annotation<T>): (ast: SchemaAST.AST) => Option.Option<T>;\n  <T>(ast: SchemaAST.AST, annotation: Annotation<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(annotation: Annotation<T>) => (ast: SchemaAST.AST) => Option.Option<T>,\n  <T>(ast: SchemaAST.AST, annotation: Annotation<T>) => Option.Option<T>\n>(2, (ast, annotation) => {\n  return internalAnnotations.getFromAst(ast, annotation);\n});\n\n/**\n * Set of annotation values.\n *\n * Can be used inside an object/relation schema:\n *\n * ```ts\n * const Person = Schema.Struct({\n *   name: Schema.String,\n *   extensions: Annotation.Dictionary,\n * });\n * ```\n */\nexport const Dictionary = internalAnnotations.Dictionary;\nexport interface Dictionary extends Schema.Schema.Type<typeof Dictionary> {}\n\n/**\n * Get the value of an annotation from a Dictionary.\n */\nexport const getDictionary: {\n  <T>(annotation: Annotation<T>): (values: Dictionary) => Option.Option<T>;\n  <T>(values: Dictionary, annotation: Annotation<T>): Option.Option<T>;\n} = Function.dual<\n  <T>(annotation: Annotation<T>) => (values: Dictionary) => Option.Option<T>,\n  <T>(values: Dictionary, annotation: Annotation<T>) => Option.Option<T>\n>(2, (values, annotation) => {\n  return internalAnnotations.getDictionary(values, annotation);\n});\n\n/**\n * Set the value of an annotation in a Dictionary.\n *\n * Can also be used within Obj.update callback:\n *\n * ```ts\n * Obj.update(obj, (obj) => {\n *   Annotation.setDictionary(obj.annotations, ColorAnnotation, 'red');\n * });\n * ```\n */\nexport const setDictionary: {\n  <T>(annotation: Annotation<T>, value: T): (values: Dictionary) => void;\n  <T>(values: Types.Mutable<Dictionary>, annotation: Annotation<T>, value: T): void;\n} = Function.dual<\n  <T>(annotation: Annotation<T>, value: T) => (values: Dictionary) => void,\n  <T>(values: Types.Mutable<Dictionary>, annotation: Annotation<T>, value: T) => void\n>(3, (values, annotation, value) => {\n  return internalAnnotations.setDictionary(values, annotation, value);\n});\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;oBAAAA;EAAA;;;;;;;;aAAAC;EAAA;;;;;aAAAC;EAAA;uBAAAC;EAAA,kBAAAC;EAAA;;;;aAAAC;EAAA;uBAAAC;EAAA;;AA8BA,YAAYC,cAAc;AASnB,IAAMC,SAAS;AAkDf,IAAMC,OAA0BA;AAuBhC,IAAMC,OAAsEC;AAO5E,IAAMC,OAGAC,cAGX,GAAG,CAACC,QAAQC,eAAAA;AACZ,SAA2BH,IAAIE,QAAQC,UAAAA;AACzC,CAAA;AAOO,IAAMC,OAGAH,cAGX,GAAG,CAACC,QAAQC,YAAYE,UAAAA;AACxB,SAA2BD,IAAIF,QAAQC,YAAYE,KAAAA;AACrD,CAAA;AAEO,IAAMC,cAGAL,cAGX,GAAG,CAACM,KAAKJ,eAAAA;AACT,SAA2BG,WAAWC,KAAKJ,UAAAA;AAC7C,CAAA;AAcO,IAAMK,cAAiCA;AAMvC,IAAMC,iBAGAR,cAGX,GAAG,CAACS,QAAQP,eAAAA;AACZ,SAA2BM,cAAcC,QAAQP,UAAAA;AACnD,CAAA;AAaO,IAAMQ,iBAGAV,cAGX,GAAG,CAACS,QAAQP,YAAYE,UAAAA;AACxB,SAA2BM,cAAcD,QAAQP,YAAYE,KAAAA;AAC/D,CAAA;",
-  "names": ["Dictionary", "Key", "get", "getDictionary", "getFromAst", "set", "setDictionary", "Function", "TypeId", "Key", "make", "makeUserAnnotation", "get", "dual", "target", "annotation", "set", "value", "getFromAst", "ast", "Dictionary", "getDictionary", "values", "setDictionary"]
-}

package/dist/lib/neutral/chunk-4ZUHOTCG.mjs

@@ -1,184 +0,0 @@
-import {
-  Ref,
-  createEchoReferenceSchema,
-  getRefSavedTarget
-} from "./chunk-WTQJHC75.mjs";
-import {
-  Dictionary,
-  MetaId,
-  getDatabase,
-  getDictionary,
-  setDictionary
-} from "./chunk-R5W6DXR4.mjs";
-import {
-  KindId,
-  SnapshotKindId
-} from "./chunk-O6BH7EPN.mjs";
-
-// src/internal/common/types/well-known-types.ts
-import { DXN } from "@dxos/keys";
-var TagTypeDXN = DXN.make("org.dxos.type.tag", "0.1.0");
-
-// src/internal/common/types/meta.ts
-import * as Schema from "effect/Schema";
-import { ForeignKey } from "@dxos/echo-protocol";
-import { invariant } from "@dxos/invariant";
-import { DXN as DXN2 } from "@dxos/keys";
-import { intersection } from "@dxos/util";
-var __dxlog_file = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/types/meta.ts";
-var ATTR_META = "@meta";
-var TagRefSchema = Schema.suspend(() => (
-  // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.
-  createEchoReferenceSchema(void 0, DXN2.getName(TagTypeDXN), DXN2.getVersion(TagTypeDXN))
-));
-var EntityMetaSchema = Schema.Struct({
-  keys: Schema.Array(ForeignKey),
-  /**
-  * Tags applied to this entity, as references to {@link Tag} objects.
-  */
-  tags: Schema.Array(TagRefSchema),
-  /**
-  * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).
-  * Identifies the canonical registry entry the object instance was created from.
-  */
-  key: Schema.optional(Schema.String),
-  /**
-  * Semantic version of the registry entry the object was created from.
-  * Must be a valid semver string (e.g. `1.2.3`).
-  */
-  version: Schema.optional(Schema.String),
-  /**
-  * Dictionary of annotations to this entity.
-  */
-  annotations: Dictionary,
-  /**
-  * Unix ms timestamp when this entity was created.
-  * Read-only; sourced from the system section of the automerge document — not stored in meta.
-  */
-  createdAt: Schema.optional(Schema.Number),
-  /**
-  * Unix ms timestamp of the last automerge change on this entity's document.
-  * Read-only; derived from the automerge change graph — not stored in meta.
-  */
-  updatedAt: Schema.optional(Schema.Number)
-});
-var getMeta = (obj) => {
-  const metadata = obj[MetaId];
-  invariant(metadata, "EntityMeta not found.", { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 63, S: void 0, A: ["metadata", "'EntityMeta not found.'"] });
-  return metadata;
-};
-var foreignKey = (source, id) => ({
-  source,
-  id
-});
-var foreignKeyEquals = (a, b) => a.source === b.source && a.id === b.id;
-var compareForeignKeys = (a, b) => intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;
-
-// src/internal/common/api/meta.ts
-import { assertArgument, invariant as invariant2 } from "@dxos/invariant";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/echo/echo/src/internal/common/api/meta.ts";
-function getMetaChecked(entity) {
-  assertArgument(entity, "entity", "Should be an entity.");
-  const meta = getMeta(entity);
-  invariant2(meta != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 9, S: this, A: ["meta != null", "'Invalid entity.'"] });
-  return meta;
-}
-var getKeys = (entity, source) => {
-  assertArgument(entity, "entity", "Should be an entity.");
-  const meta = getMetaChecked(entity);
-  invariant2(meta != null, "Invalid entity.", { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 18, S: void 0, A: ["meta != null", "'Invalid entity.'"] });
-  return meta.keys.filter((key) => key.source === source);
-};
-var deleteKeys = (entity, source) => {
-  const meta = getMetaChecked(entity);
-  for (let i = 0; i < meta.keys.length; i++) {
-    if (meta.keys[i].source === source) {
-      meta.keys.splice(i, 1);
-      i--;
-    }
-  }
-};
-var addTag = (entity, tag) => {
-  const meta = getMetaChecked(entity);
-  if (!meta.tags.some((existing) => existing.uri === tag.uri)) {
-    meta.tags.push(tag);
-  }
-};
-var removeTag = (entity, tag) => {
-  const meta = getMetaChecked(entity);
-  for (let i = 0; i < meta.tags.length; i++) {
-    if (meta.tags[i].uri === tag.uri) {
-      meta.tags.splice(i, 1);
-      i--;
-    }
-  }
-};
-
-// src/internal/Entity/guard.ts
-var isEntity = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  return value[KindId] !== void 0;
-};
-var isSnapshot = (value) => {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  return value[SnapshotKindId] !== void 0;
-};
-
-// src/internal/Annotation/entity-dictionary.ts
-import { deepMapValues } from "@dxos/util";
-var get = (target, annotation) => {
-  if (isEntity(target) || isSnapshot(target)) {
-    const meta = getMetaChecked(target);
-    return getDictionary(meta.annotations, annotation);
-  } else {
-    throw new TypeError("Target is not an annotation target.");
-  }
-};
-var set = (target, annotation, value) => {
-  if (isEntity(target)) {
-    const meta = getMetaChecked(target);
-    persistRefTargets(target, value);
-    setDictionary(meta.annotations, annotation, value);
-  } else {
-    throw new TypeError("Target is not an annotation target.");
-  }
-};
-var persistRefTargets = (host, value) => {
-  const database = getDatabase(host);
-  if (database == null) {
-    return;
-  }
-  deepMapValues(value, (current, recurse) => {
-    if (Ref.isRef(current)) {
-      const refTarget = getRefSavedTarget(current);
-      if (refTarget != null && isEntity(refTarget) && getDatabase(refTarget) == null) {
-        database.add(refTarget);
-      }
-      return current;
-    }
-    return recurse(current);
-  });
-};
-
-export {
-  TagTypeDXN,
-  ATTR_META,
-  EntityMetaSchema,
-  getMeta,
-  foreignKey,
-  foreignKeyEquals,
-  compareForeignKeys,
-  getMetaChecked,
-  getKeys,
-  deleteKeys,
-  addTag,
-  removeTag,
-  isEntity,
-  get,
-  set
-};
-//# sourceMappingURL=chunk-4ZUHOTCG.mjs.map

package/dist/lib/neutral/chunk-4ZUHOTCG.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/internal/common/types/well-known-types.ts", "../../../src/internal/common/types/meta.ts", "../../../src/internal/common/api/meta.ts", "../../../src/internal/Entity/guard.ts", "../../../src/internal/Annotation/entity-dictionary.ts"],
-  "sourcesContent": ["//\n// Copyright 2026 DXOS.org\n//\n\nimport { DXN } from '@dxos/keys';\n\n/**\n * DXN identity of the system {@link Tag} type.\n *\n * Defined in this low-level leaf so it can be shared by the public `Tag` type (which brands the\n * schema with this DXN) and by `EntityMetaSchema.tags` (which builds a `Ref<Tag>` schema from it)\n * without either importing the other — `Tag` is top-level and `meta` is deep-internal, so a direct\n * dependency between them would form an eval-order cycle.\n */\nexport const TagTypeDXN = DXN.make('org.dxos.type.tag', '0.1.0');\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Schema from 'effect/Schema';\n\nimport { type EncodedReference, ForeignKey } from '@dxos/echo-protocol';\nimport { invariant } from '@dxos/invariant';\nimport { DXN } from '@dxos/keys';\nimport { type Comparator, intersection } from '@dxos/util';\n\nimport type * as Tag from '../../../Tag';\nimport { Dictionary } from '../../Annotation/dictionary';\n// `meta` is no longer re-exported from the `common/types` barrel (see ./index.ts), so importing the\n// Ref schema builder here no longer forms an eval-order cycle with `Annotation`/`Database`.\nimport { type Ref, createEchoReferenceSchema } from '../../Ref/ref';\nimport { type AnyProperties } from './base';\nimport { MetaId } from './model-symbols';\nimport { TagTypeDXN } from './well-known-types';\n\n/**\n * Property name for meta when object is serialized to JSON.\n */\nexport const ATTR_META = '@meta';\n\n//\n// EntityMeta\n//\n\n/**\n * Schema for references to {@link Tag} objects stored in {@link EntityMetaSchema.tags}.\n *\n * Built from the shared {@link createEchoReferenceSchema} (the same builder `Ref.Ref` uses) via\n * `Schema.suspend`, so it reuses the canonical ref codec rather than duplicating it. The Tag type\n * identity comes from the shared {@link TagTypeDXN} constant; `suspend` defers construction until\n * first use, and `Tag` is referenced type-only, so no `Tag` value import is needed.\n */\nconst TagRefSchema = Schema.suspend(\n  (): Schema.Schema<Ref<Tag.Tag>, EncodedReference> =>\n    // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.\n    createEchoReferenceSchema(undefined, DXN.getName(TagTypeDXN), DXN.getVersion(TagTypeDXN)) as Schema.Schema<\n      Ref<Tag.Tag>,\n      EncodedReference\n    >,\n);\n\nexport const EntityMetaSchema = Schema.Struct({\n  keys: Schema.Array(ForeignKey),\n\n  /**\n   * Tags applied to this entity, as references to {@link Tag} objects.\n   */\n  tags: Schema.Array(TagRefSchema),\n\n  /**\n   * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).\n   * Identifies the canonical registry entry the object instance was created from.\n   */\n  key: Schema.optional(Schema.String),\n\n  /**\n   * Semantic version of the registry entry the object was created from.\n   * Must be a valid semver string (e.g. `1.2.3`).\n   */\n  version: Schema.optional(Schema.String),\n\n  /**\n   * Dictionary of annotations to this entity.\n   */\n  annotations: Dictionary,\n\n  /**\n   * Unix ms timestamp when this entity was created.\n   * Read-only; sourced from the system section of the automerge document — not stored in meta.\n   */\n  createdAt: Schema.optional(Schema.Number),\n\n  /**\n   * Unix ms timestamp of the last automerge change on this entity's document.\n   * Read-only; derived from the automerge change graph — not stored in meta.\n   */\n  updatedAt: Schema.optional(Schema.Number),\n});\n\nexport type EntityMeta = Schema.Schema.Type<typeof EntityMetaSchema>;\n\n/*\n * Get metadata from object.\n * Only callable on the object root.\n *\n * @internal (use Obj.getMeta or Relation.getMeta)\n */\n// TODO(burdon): Refine type to BaseObj.\nexport const getMeta = (obj: AnyProperties): EntityMeta => {\n  const metadata = (obj as any)[MetaId];\n  invariant(metadata, 'EntityMeta not found.');\n  return metadata;\n};\n\n//\n// Foreign keys\n//\n\nexport const foreignKey = (source: string, id: string): ForeignKey => ({ source, id });\nexport const foreignKeyEquals = (a: ForeignKey, b: ForeignKey) => a.source === b.source && a.id === b.id;\n\n// TODO(dmaretskyi): Move to echo-schema.\nexport const compareForeignKeys: Comparator<AnyProperties> = (a: AnyProperties, b: AnyProperties) =>\n  intersection(getMeta(a).keys, getMeta(b).keys, foreignKeyEquals).length > 0;\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport type { ForeignKey } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport type { DeepReadonly } from '@dxos/util';\n\nimport type * as Tag from '../../../Tag';\nimport type { Ref } from '../../Ref/ref';\nimport { type Mutable } from '../proxy';\nimport { type AnyProperties } from '../types';\nimport { type EntityMeta, getMeta as getMeta$ } from '../types/meta';\n\n/**\n * Deeply read-only version of EntityMeta.\n */\nexport type ReadonlyMeta = DeepReadonly<EntityMeta>;\n\n/**\n * Mutable meta type received in meta mutation callbacks.\n */\nexport type Meta = Mutable<EntityMeta>;\n\n/**\n * Get the metadata for an entity with validation.\n * Returns mutable meta when passed a mutable entity (inside change callback).\n * Returns read-only meta when passed a regular entity or snapshot.\n *\n * TODO(burdon): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.\n */\nexport function getMetaChecked(entity: Mutable<AnyProperties>): Meta;\nexport function getMetaChecked(entity: AnyProperties): ReadonlyMeta;\nexport function getMetaChecked(entity: AnyProperties): Meta | ReadonlyMeta {\n  assertArgument(entity, 'entity', 'Should be an entity.');\n  const meta = getMeta$(entity);\n  invariant(meta != null, 'Invalid entity.');\n  return meta;\n}\n\n/**\n * @returns Foreign keys for the entity from the specified source.\n * Accepts both reactive entities and snapshots.\n */\nexport const getKeys = (entity: AnyProperties, source: string): ForeignKey[] => {\n  assertArgument(entity, 'entity', 'Should be an entity.');\n  const meta = getMetaChecked(entity);\n  invariant(meta != null, 'Invalid entity.');\n  return meta.keys.filter((key) => key.source === source);\n};\n\n/**\n * Delete all keys from the entity for the specified source.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const deleteKeys = (entity: Mutable<AnyProperties>, source: string) => {\n  const meta = getMetaChecked(entity);\n  for (let i = 0; i < meta.keys.length; i++) {\n    if (meta.keys[i].source === source) {\n      meta.keys.splice(i, 1);\n      i--;\n    }\n  }\n};\n\n/**\n * Add a tag (a reference to a {@link Tag} object) to the entity. Idempotent.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const addTag = (entity: Mutable<AnyProperties>, tag: Ref<Tag.Tag>) => {\n  const meta = getMetaChecked(entity);\n  // Two refs to the same target are not `===`; dedupe by URI.\n  if (!meta.tags.some((existing) => existing.uri === tag.uri)) {\n    meta.tags.push(tag);\n  }\n};\n\n/**\n * Remove a tag (a reference to a {@link Tag} object) from the entity. No-op when not present.\n * Must be called within an Obj.update or Relation.update callback.\n */\nexport const removeTag = (entity: Mutable<AnyProperties>, tag: Ref<Tag.Tag>) => {\n  const meta = getMetaChecked(entity);\n  for (let i = 0; i < meta.tags.length; i++) {\n    if (meta.tags[i].uri === tag.uri) {\n      meta.tags.splice(i, 1);\n      i--;\n    }\n  }\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport type * as Entity from '../../Entity';\nimport { KindId, SnapshotKindId } from '../common/types';\n\n/**\n * Returns true if the value is an ECHO entity instance (object or relation).\n */\nexport const isEntity = (value: unknown): value is Entity.Unknown => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[KindId] !== undefined;\n};\n\n/**\n * Returns true if the value is an ECHO entity snapshot.\n */\nexport const isSnapshot = (value: unknown): value is Entity.Snapshot => {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  return (value as any)[SnapshotKindId] !== undefined;\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport * as Option from 'effect/Option';\n\nimport { deepMapValues } from '@dxos/util';\n\nimport type * as Annotation from '../../Annotation';\nimport type * as Entity from '../../Entity';\nimport { getMetaChecked } from '../common/api/meta';\nimport { type Mutable } from '../common/proxy/reactive';\nimport { getDatabase } from '../Entity/api';\nimport { isEntity, isSnapshot } from '../Entity/guard';\nimport { Ref, getRefSavedTarget } from '../Ref';\nimport { getDictionary, setDictionary } from './dictionary';\n\n/**\n * Get the value of an annotation from an entity instance or snapshot.\n */\nexport const get = <T>(\n  target: Entity.Unknown | Entity.Snapshot,\n  annotation: Annotation.Annotation<T>,\n): Option.Option<T> => {\n  if (isEntity(target) || isSnapshot(target)) {\n    const meta = getMetaChecked(target);\n    return getDictionary(meta.annotations, annotation);\n  } else {\n    throw new TypeError('Target is not an annotation target.');\n  }\n};\n\n/**\n * Set the value of an annotation on an entity instance.\n * Must be called with a mutable entity — i.e. inside an `Obj.update` callback.\n */\nexport const set = <T>(target: Mutable<Entity.Unknown>, annotation: Annotation.Annotation<T>, value: T): void => {\n  if (isEntity(target)) {\n    const meta = getMetaChecked(target);\n    // Persist any unsaved Ref targets in the value into the entity's database so\n    // the encoded DXN resolves on read. This mirrors normal property assignment,\n    // where the reactive proxy links unsaved ref targets via `createRef` →\n    // `database.add`. `setDictionary` pre-encodes the value (`Schema.encodeSync`),\n    // so the live Ref never reaches the proxy's link handling and would otherwise\n    // be stored as a dangling reference.\n    persistRefTargets(target, value);\n    setDictionary(meta.annotations, annotation, value);\n  } else {\n    throw new TypeError('Target is not an annotation target.');\n  }\n};\n\n/**\n * Add any unsaved Ref targets found in `value` to the host entity's database, matching the\n * auto-persistence applied to refs assigned to ordinary entity properties. Refs whose target\n * already lives in a database (the host's or a foreign one) are left untouched.\n */\nconst persistRefTargets = (host: Entity.Unknown, value: unknown): void => {\n  const database = getDatabase(host);\n  if (database == null) {\n    return;\n  }\n\n  deepMapValues(value, (current, recurse) => {\n    if (Ref.isRef(current)) {\n      const refTarget = getRefSavedTarget(current);\n      if (refTarget != null && isEntity(refTarget) && getDatabase(refTarget) == null) {\n        database.add(refTarget);\n      }\n      return current;\n    }\n    return recurse(current);\n  });\n};\n"],
-  "mappings": "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",
-  "names": ["DXN", "TagTypeDXN", "make", "Schema", "ForeignKey", "invariant", "DXN", "intersection", "Schema", "Struct", "keys", "ForeignKey", "invariant", "metadata", "id", "compareForeignKeys", "a", "b", "intersection", "getMeta", "assertArgument", "invariant", "__dxlog_file", "getMetaChecked", "meta", "entity", "invariant", "keys", "key", "source", "splice", "i", "tags", "existing", "length", "uri", "isEntity", "value", "KindId", "undefined", "isSnapshot", "SnapshotKindId", "deepMapValues", "get", "target", "annotation", "isEntity", "isSnapshot", "meta", "getMetaChecked", "getDictionary", "annotations", "TypeError", "set", "value", "persistRefTargets", "setDictionary", "host", "database", "getDatabase", "deepMapValues", "current", "recurse", "Ref", "isRef", "refTarget", "getRefSavedTarget", "add"]
-}