@dxos/echo 0.8.4-main.66e292d → 0.8.4-main.69d29f4

package/src/internal/json-schema/json-schema.test.ts

@@ -35,7 +35,7 @@ const EXAMPLE_NAMESPACE = '@example';
 describe('effect-to-json', () => {
   test('type annotation', () => {
     const Test = Schema.Struct({ name: Schema.String }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -50,7 +50,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Schema.String.pipe(PropertyMeta(EXAMPLE_NAMESPACE, meta)),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -63,7 +63,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -71,7 +71,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Ref(Nested),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -88,7 +88,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -96,7 +96,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Ref(Nested).annotations({ [FieldLookupAnnotationId]: 'name' }),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -112,7 +112,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -120,7 +120,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Schema.Array(Ref(Nested)),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -134,7 +134,7 @@ describe('effect-to-json', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/TestNested',
         version: '0.1.0',
       }),
@@ -142,7 +142,7 @@ describe('effect-to-json', () => {
     const Test = Schema.Struct({
       name: Schema.optional(Ref(Nested)),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Test',
         version: '0.1.0',
       }),
@@ -165,7 +165,7 @@ describe('effect-to-json', () => {
         description: 'Email address',
       }),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Person',
         version: '0.1.0',
       }),
@@ -204,9 +204,11 @@ describe('effect-to-json', () => {
       'name',
       'username',
       'email',
+      'age',
       'tasks',
       'employer',
       'address',
+      'fields',
     ]);
   });
 
@@ -214,7 +216,7 @@ describe('effect-to-json', () => {
     const Organization = Schema.Struct({
       field: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Organization',
         version: '0.1.0',
       }),
@@ -224,7 +226,7 @@ describe('effect-to-json', () => {
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Person',
         version: '0.1.0',
       }),
@@ -276,7 +278,7 @@ describe('effect-to-json', () => {
     const Organization = Schema.Struct({
       field: Schema.String,
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Organization',
         version: '0.1.0',
       }),
@@ -286,7 +288,7 @@ describe('effect-to-json', () => {
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
     }).pipe(
-      Type.Obj({
+      Type.object({
         typename: 'example.com/type/Person',
         version: '0.1.0',
       }),
@@ -494,7 +496,7 @@ describe('json-to-effect', () => {
       const Organization = Schema.Struct({
         field: Schema.String,
       }).pipe(
-        Type.Obj({
+        Type.object({
           typename: 'example.com/type/Organization',
           version: '0.1.0',
         }),
@@ -515,7 +517,7 @@ describe('json-to-effect', () => {
       } as const;
 
       const Test = (partial ? Schema.partial(Schema.Struct(fields)) : Schema.Struct(fields)).pipe(
-        Type.Obj({
+        Type.object({
           typename: 'example.com/type/Test',
           version: '0.1.0',
         }),

package/src/internal/json-schema/json-schema.ts

@@ -23,9 +23,8 @@ import {
   TypeIdentifierAnnotationId,
   makeTypeJsonSchemaAnnotation,
 } from '../annotations';
-import { Expando } from '../entities';
-import { type JsonSchemaReferenceInfo, Ref, createEchoReferenceSchema } from '../ref';
-import { EntityKind, EntityKindSchema } from '../types';
+import { type JsonSchemaReferenceInfo, createEchoReferenceSchema } from '../ref';
+import { ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION, EntityKind, EntityKindSchema } from '../types';
 
 import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
 import {
@@ -81,7 +80,11 @@ export type JsonSchemaOptions = {
  */
 // TODO(burdon): Reconcile with possibly extending @effect/Schema/JSONSchema
 //  We add additional propertyOrder (but the object properties ARE ordered); and type "string" for literals.
-export const toJsonSchema = (schema: Schema.Schema.All, options: JsonSchemaOptions = {}): JsonSchemaType => {
+// TODO(wittjosiah): This is mutable because its a pojo, perhaps should be left as readonly at type level though?
+export const toJsonSchema = (
+  schema: Schema.Schema.All,
+  options: JsonSchemaOptions = {},
+): Types.DeepMutable<JsonSchemaType> => {
   assertArgument(Schema.isSchema(schema), 'schema');
   let jsonSchema = _toJsonSchemaAST(schema.ast);
   if (options.strict) {
@@ -104,11 +107,11 @@ export const toJsonSchema = (schema: Schema.Schema.All, options: JsonSchemaOptio
   return jsonSchema;
 };
 
-const _toJsonSchemaAST = (ast: SchemaAST.AST): JsonSchemaType => {
+const _toJsonSchemaAST = (ast: SchemaAST.AST): Types.DeepMutable<JsonSchemaType> => {
   const withRefinements = withEchoRefinements(ast, '#');
   const jsonSchema = JSONSchema.fromAST(withRefinements, {
     definitions: {},
-  }) as JsonSchemaType;
+  }) as Types.DeepMutable<JsonSchemaType>;
 
   return normalizeJsonSchema(jsonSchema);
 };
@@ -327,7 +330,7 @@ const objectToEffectSchema = (root: JsonSchemaType, defs: JsonSchemaType['$defs'
   }
 
   if (immutableIdField) {
-    schema = Schema.extend(Schema.mutable(schema), Schema.Struct({ id: immutableIdField }));
+    schema = Schema.extend(schema, Schema.Struct({ id: immutableIdField }));
   }
 
   const annotations = jsonSchemaFieldsToAnnotations(root);
@@ -352,7 +355,8 @@ const anyToEffectSchema = (root: JSONSchema.JsonSchema7Any): Schema.Schema.AnyNo
 // TODO(dmaretskyi): Types.
 const refToEffectSchema = (root: any): Schema.Schema.AnyNoContext => {
   if (!('reference' in root)) {
-    return Ref(Expando);
+    // Fallback to generic object ref when no reference info is provided.
+    return createEchoReferenceSchema(undefined, ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION);
   }
 
   const reference: JsonSchemaReferenceInfo = root.reference;
@@ -377,7 +381,7 @@ const refToEffectSchema = (root: any): Schema.Schema.AnyNoContext => {
 const annotations_toJsonSchemaFields = (annotations: SchemaAST.Annotations): Record<symbol, any> => {
   const schemaFields: Record<string, any> = {};
 
-  const echoAnnotations: JsonSchemaEchoAnnotations = {};
+  const echoAnnotations: Types.Mutable<JsonSchemaEchoAnnotations> = {};
   for (const [key, annotationId] of Object.entries(EchoAnnotations)) {
     if (annotations[annotationId] != null) {
       echoAnnotations[key as keyof JsonSchemaEchoAnnotations] = annotations[annotationId] as any;
@@ -495,7 +499,7 @@ const addJsonSchemaFields = (ast: SchemaAST.AST, schema: JsonSchemaType): Schema
  * Fixes field order.
  * Sets `$schema` prop.
  */
-const normalizeJsonSchema = (jsonSchema: JsonSchemaType): JsonSchemaType => {
+const normalizeJsonSchema = (jsonSchema: Types.DeepMutable<JsonSchemaType>): Types.DeepMutable<JsonSchemaType> => {
   if (jsonSchema.properties && 'id' in jsonSchema.properties) {
     jsonSchema.properties = orderKeys(jsonSchema.properties, ['id']); // Put id first.
   }

package/src/internal/object/clone.ts

@@ -0,0 +1,48 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+import { deepMapValues } from '@dxos/util';
+
+import type * as Obj from '../../Obj';
+import { makeObject } from '../proxy';
+import { Ref } from '../ref';
+import { getMeta, getSchema } from '../types';
+
+/**
+ * Clones an object or relation.
+ * This does not clone referenced objects, only the properties in the object.
+ * @returns A new object with the same schema and properties.
+ */
+export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T => {
+  const { id, ...data } = obj;
+  const schema = getSchema(obj);
+  invariant(schema != null, 'Object should have a schema');
+  const props: any = deepMapValues(data, (value, recurse) => {
+    if (Ref.isRef(value)) {
+      if (opts?.deep) {
+        // TODO(dmaretskyi): Will break on circular references.
+        return Ref.make(clone(value.target!, opts));
+      }
+      return value;
+    }
+    return recurse(value);
+  });
+
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = deepMapValues(getMeta(obj), (value, recurse) => {
+    if (Ref.isRef(value)) {
+      if (opts?.deep) {
+        // TODO(dmaretskyi): Will break on circular references.
+        return Ref.make(clone(value.target!, opts));
+      }
+      return value;
+    }
+    return recurse(value);
+  });
+
+  return makeObject(schema, props, meta);
+};

package/src/internal/object/create-object.ts

@@ -7,7 +7,6 @@ import type * as Schema from 'effect/Schema';
 import { raise } from '@dxos/debug';
 import { assertArgument, failedInvariant } from '@dxos/invariant';
 import { ObjectId } from '@dxos/keys';
-import { defineHiddenProperty } from '@dxos/live-object';
 
 import { getSchemaDXN, getTypeAnnotation, setTypename } from '../annotations';
 import {
@@ -18,6 +17,7 @@ import {
   assertObjectModel,
   getObjectDXN,
 } from '../entities';
+import { defineHiddenProperty } from '../proxy';
 import { EntityKind, KindId, MetaId, setSchema } from '../types';
 
 import { attachedTypedObjectInspector } from './inspect';
@@ -41,7 +41,7 @@ export type CreateObjectProps<T> = T extends { id: string } ? Omit<T, 'id' | Kin
  * const Contact = Schema.Struct({
  *   name: Schema.String,
  *   email: Schema.String,
- * }).pipe(Type.Obj({
+ * }).pipe(Type.object({
  *   typename: 'example.com/type/Person',
  *   version: '0.1.0',
  * }))

package/src/internal/object/index.ts

@@ -8,4 +8,7 @@ export * from './deleted';
 export * from './ids';
 export * from './json-serializer';
 export * from './schema-validator';
+export * from './set-value';
+export * from './snapshot';
 export * from './typed-object';
+export * from './clone';

package/src/internal/object/inspect.ts

@@ -7,7 +7,7 @@ import type { InspectOptionsStylized, inspect as inspectFn } from 'node:util';
 import { type CustomInspectFunction, inspectCustom } from '@dxos/debug';
 
 import { getTypeDXN } from '../annotations';
-import { ATTR_META, ATTR_TYPE, type AnyEchoObject, MetaId } from '../types';
+import { ATTR_META, ATTR_TYPE, type AnyEntity, MetaId } from '../types';
 
 /*
  * @internal
@@ -27,8 +27,8 @@ export const attachedTypedObjectInspector = (obj: any) => {
 };
 
 // NOTE: KEEP as function.
-const typedObjectInspectFunction: CustomInspectFunction<AnyEchoObject> = function (
-  this: AnyEchoObject,
+const typedObjectInspectFunction: CustomInspectFunction<AnyEntity> = function (
+  this: AnyEntity,
   depth: number,
   options: InspectOptionsStylized,
   inspect: typeof inspectFn,

package/src/internal/object/json-serializer.test.ts

@@ -6,12 +6,14 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN } from '@dxos/keys';
 
+import * as Obj from '../../Obj';
 import { TestSchema } from '../../testing';
 import { getSchemaDXN, getSchemaTypename, getTypeDXN, getTypename } from '../annotations';
+import { getMetaChecked } from '../api';
 import { RelationSourceId, RelationTargetId, getObjectDXN } from '../entities';
 import { makeObject } from '../proxy';
 import { Ref, StaticRefResolver } from '../ref';
-import { ATTR_TYPE, EntityKind, KindId, MetaId, TypeId, getMeta, getSchema } from '../types';
+import { ATTR_TYPE, EntityKind, KindId, MetaId, TypeId, getSchema } from '../types';
 
 import { createObject } from './create-object';
 import { objectFromJSON, objectToJSON } from './json-serializer';
@@ -19,7 +21,9 @@ import { objectFromJSON, objectToJSON } from './json-serializer';
 describe('Object JSON serializer', () => {
   test('should serialize and deserialize object', async () => {
     const contact = makeObject(TestSchema.Person, { name: 'Alice' });
-    getMeta(contact).keys.push({ id: '12345', source: 'example.com' });
+    Obj.change(contact, (c) => {
+      getMetaChecked(c).keys.push({ id: '12345', source: 'example.com' });
+    });
 
     const task = createObject(TestSchema.Task, {
       title: 'Fix the tests',

package/src/internal/object/json-serializer.ts

@@ -5,12 +5,12 @@
 import * as Schema from 'effect/Schema';
 
 import { raise } from '@dxos/debug';
-import { type EncodedReference, type ObjectMeta, isEncodedReference } from '@dxos/echo-protocol';
+import { type EncodedReference, ObjectStructure, isEncodedReference } from '@dxos/echo-protocol';
 import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
-import { defineHiddenProperty } from '@dxos/live-object';
 import { assumeType, deepMapValues, visitValues } from '@dxos/util';
 
+import type * as Obj from '../../Obj';
 import { getTypeDXN, setTypename } from '../annotations';
 import {
   ATTR_DELETED,
@@ -25,19 +25,22 @@ import {
   SelfDXNId,
   assertObjectModel,
 } from '../entities';
+import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../proxy';
 import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../ref';
 import {
   ATTR_META,
   ATTR_TYPE,
-  type AnyEchoObject,
+  type AnyEntity,
   EntityKind,
   KindId,
   MetaId,
   ObjectMetaSchema,
-  TypeId,
   setSchema,
 } from '../types';
 
+// Re-export for backward compatibility.
+export { attachTypedJsonSerializer };
+
 type DeepReplaceRef<T> =
   T extends Ref<any>
     ? EncodedReference
@@ -54,7 +57,7 @@ type SerializedObject<T extends { id: string }> = {
 /**
  * Converts object to it's JSON representation.
  */
-export const objectToJSON = <T extends AnyEchoObject>(obj: T): SerializedObject<T> => {
+export const objectToJSON = <T extends AnyEntity>(obj: T): SerializedObject<T> => {
   const typename = getTypeDXN(obj)?.toString();
   invariant(typename && typeof typename === 'string');
   return typedJsonSerializer.call(obj);
@@ -69,7 +72,7 @@ export const objectToJSON = <T extends AnyEchoObject>(obj: T): SerializedObject<
 export const objectFromJSON = async (
   jsonData: unknown,
   { refResolver, dxn }: { refResolver?: RefResolver; dxn?: DXN } = {},
-): Promise<AnyEchoObject> => {
+): Promise<AnyEntity> => {
   assumeType<ObjectJSON>(jsonData);
   assertArgument(typeof jsonData === 'object' && jsonData !== null, 'jsonData', 'expect object');
   assertArgument(typeof jsonData[ATTR_TYPE] === 'string', 'jsonData[ATTR_TYPE]', 'expected object to have a type');
@@ -101,8 +104,8 @@ export const objectFromJSON = async (
     const sourceDxn: DXN = DXN.parse(jsonData[ATTR_RELATION_SOURCE] ?? raise(new TypeError('Missing relation source')));
     const targetDxn: DXN = DXN.parse(jsonData[ATTR_RELATION_TARGET] ?? raise(new TypeError('Missing relation target')));
 
-    const source = (await refResolver?.resolve(sourceDxn)) as AnyEchoObject | undefined;
-    const target = (await refResolver?.resolve(targetDxn)) as AnyEchoObject | undefined;
+    const source = (await refResolver?.resolve(sourceDxn)) as AnyEntity | undefined;
+    const target = (await refResolver?.resolve(targetDxn)) as AnyEntity | undefined;
 
     defineHiddenProperty(obj, KindId, EntityKind.Relation);
     defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
@@ -117,6 +120,10 @@ export const objectFromJSON = async (
     const meta = await ObjectMetaSchema.pipe(Schema.decodeUnknownPromise)(jsonData[ATTR_META]);
     invariant(Array.isArray(meta.keys));
     defineHiddenProperty(obj, MetaId, meta);
+  } else {
+    defineHiddenProperty(obj, MetaId, {
+      keys: [],
+    });
   }
 
   if (dxn) {
@@ -153,7 +160,7 @@ const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }
   });
 };
 
-export const setRefResolverOnData = (obj: AnyEchoObject, refResolver: RefResolver) => {
+export const setRefResolverOnData = (obj: AnyEntity, refResolver: RefResolver) => {
   const visitor = (value: unknown) => {
     if (Ref.isRef(value)) {
       setRefResolver(value, refResolver);
@@ -165,66 +172,17 @@ export const setRefResolverOnData = (obj: AnyEchoObject, refResolver: RefResolve
   visitor(obj);
 };
 
-export const attachTypedJsonSerializer = (obj: any) => {
-  const descriptor = Object.getOwnPropertyDescriptor(obj, 'toJSON');
-  if (descriptor) {
-    return;
-  }
-
-  Object.defineProperty(obj, 'toJSON', {
-    value: typedJsonSerializer,
-    writable: false,
-    enumerable: false,
-    // Setting `configurable` to false breaks proxy invariants, should be fixable.
-    configurable: true,
-  });
-};
-
-// NOTE: KEEP as function.
-const typedJsonSerializer = function (this: any) {
-  const { id, ...rest } = this;
-  const result: any = {
-    id,
+/**
+ * Convert ObjectStructure to JSON data for indexing.
+ * Different from {@link objectToJSON} as it takes the internal {@link ObjectStructure} representation directly
+ */
+export const objectStructureToJson = (objectId: string, structure: ObjectStructure): Obj.JSON => {
+  return {
+    ...structure.data,
+    id: objectId,
+    [ATTR_TYPE]: (ObjectStructure.getTypeReference(structure)?.['/'] ?? '') as DXN.String,
+    [ATTR_DELETED]: ObjectStructure.isDeleted(structure),
+    [ATTR_RELATION_SOURCE]: ObjectStructure.getRelationSource(structure)?.['/'] as DXN.String | undefined,
+    [ATTR_RELATION_TARGET]: ObjectStructure.getRelationTarget(structure)?.['/'] as DXN.String | undefined,
   };
-
-  if (this[TypeId]) {
-    result[ATTR_TYPE] = this[TypeId].toString();
-  }
-
-  if (this[MetaId]) {
-    result[ATTR_META] = serializeMeta(this[MetaId]);
-  }
-
-  if (this[SelfDXNId]) {
-    result[ATTR_SELF_DXN] = this[SelfDXNId].toString();
-  }
-
-  if (this[RelationSourceDXNId]) {
-    const sourceDXN = this[RelationSourceDXNId];
-    invariant(sourceDXN instanceof DXN);
-    result[ATTR_RELATION_SOURCE] = sourceDXN.toString();
-  }
-  if (this[RelationTargetDXNId]) {
-    const targetDXN = this[RelationTargetDXNId];
-    invariant(targetDXN instanceof DXN);
-    result[ATTR_RELATION_TARGET] = targetDXN.toString();
-  }
-
-  Object.assign(result, serializeData(rest));
-  return result;
-};
-
-const serializeData = (data: unknown) => {
-  return deepMapValues(data, (value, recurse) => {
-    if (Ref.isRef(value)) {
-      // TODO(dmaretskyi): Should this be configurable?
-      return value.noInline().encode();
-    }
-
-    return recurse(value);
-  });
-};
-
-const serializeMeta = (meta: ObjectMeta) => {
-  return deepMapValues(meta, (value, recurse) => recurse(value));
 };

package/src/internal/object/schema-validator.test.ts

@@ -27,9 +27,7 @@ describe('schema-validator', () => {
       const TestSchema: Schema.Schema.AnyNoContext = Schema.Struct({
         name: Schema.String.annotations({ [annotationId]: annotationValue }),
         parent: Schema.optional(Schema.suspend(() => TestSchema.annotations({ [annotationId]: annotationValue }))),
-        friends: Schema.suspend(() =>
-          Schema.mutable(Schema.Array(TestSchema.annotations({ [annotationId]: annotationValue }))),
-        ),
+        friends: Schema.suspend(() => Schema.Array(TestSchema.annotations({ [annotationId]: annotationValue }))),
       });
       expect(SchemaValidator.hasTypeAnnotation(TestSchema, 'name', annotationId)).to.be.true;
       expect(SchemaValidator.hasTypeAnnotation(TestSchema, 'parent', annotationId)).to.be.true;
@@ -41,7 +39,7 @@ describe('schema-validator', () => {
       const Person: Schema.Schema.AnyNoContext = Schema.Struct({
         name: Schema.String,
         parent: Schema.optional(Schema.suspend(() => Person)),
-        friends: Schema.suspend(() => Schema.mutable(Schema.Array(Person))),
+        friends: Schema.suspend(() => Schema.Array(Person)),
       });
       expect(SchemaValidator.hasTypeAnnotation(Person, 'name', annotationId)).to.be.false;
       expect(SchemaValidator.hasTypeAnnotation(Person, 'parent', annotationId)).to.be.false;
@@ -87,9 +85,7 @@ describe('schema-validator', () => {
       const annotationValue = 'bar';
       const Person: Schema.Schema.AnyNoContext = Schema.Struct({
         parent: Schema.optional(Schema.suspend(() => Person.annotations({ [annotationId]: annotationValue }))),
-        friends: Schema.suspend(() =>
-          Schema.mutable(Schema.Array(Person.annotations({ [annotationId]: annotationValue }))),
-        ),
+        friends: Schema.suspend(() => Schema.Array(Person.annotations({ [annotationId]: annotationValue }))),
       });
       expect(SchemaValidator.getPropertySchema(Person, ['parent']).ast.annotations[annotationId]).to.eq(
         annotationValue,