@dxos/echo 0.8.4-main.e8ec1fe → 0.8.4-main.ef1bc66f44

package/src/internal/{json → json-schema}/json-schema.ts

@@ -17,19 +17,23 @@ import { DXN, ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { clearUndefined, orderKeys, removeProperties } from '@dxos/util';
 
-import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../ast';
-import { EntityKind, EntityKindSchema } from '../ast';
+import {
+  type TypeAnnotation,
+  TypeAnnotationId,
+  TypeIdentifierAnnotationId,
+  makeTypeJsonSchemaAnnotation,
+} from '../annotations';
+import { type JsonSchemaReferenceInfo, createEchoReferenceSchema } from '../ref';
+import { ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION, EntityKind, EntityKindSchema } from '../types';
+
+import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
 import {
   ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
   ECHO_ANNOTATIONS_NS_KEY,
   type JsonSchemaEchoAnnotations,
   type JsonSchemaType,
   getNormalizedEchoAnnotations,
-} from '../json-schema';
-import { Expando, makeTypeJsonSchemaAnnotation } from '../object';
-import { type JsonSchemaReferenceInfo, Ref, createEchoReferenceSchema } from '../ref';
-
-import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
+} from './json-schema-type';
 
 // TODO(burdon): Are these values stored (can they be changed?)
 export enum PropType {
@@ -71,9 +75,16 @@ export type JsonSchemaOptions = {
 
 /**
  * Convert effect schema to JSON Schema.
+ * NOTE: This handles custom annotations.
  * @param schema
  */
-export const toJsonSchema = (schema: Schema.Schema.All, options: JsonSchemaOptions = {}): JsonSchemaType => {
+// TODO(burdon): Reconcile with possibly extending @effect/Schema/JSONSchema
+//  We add additional propertyOrder (but the object properties ARE ordered); and type "string" for literals.
+// 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) {
@@ -96,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);
 };
@@ -319,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);
@@ -344,8 +355,10 @@ 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;
   if (typeof reference !== 'object') {
     throw new Error('Invalid reference field in ref schema');
@@ -368,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;
@@ -486,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/common.ts

@@ -4,9 +4,8 @@
 
 import * as Schema from 'effect/Schema';
 
-import { type BaseObject } from '../types';
-
-import { getTypename } from './typename';
+import { getTypename } from '../annotations';
+import { type AnyProperties } from '../types';
 
 // TODO(dmaretskyi): Rename to represent commonality between objects and relations (e.g. `entity`).
 export type TypedObjectOptions = {
@@ -58,7 +57,7 @@ export const makeTypedEntityClass = (
     static readonly pipe = baseSchema.pipe.bind(baseSchema);
 
     // TODO(burdon): Comment required.
-    static [Symbol.hasInstance](obj: BaseObject) {
+    static [Symbol.hasInstance](obj: AnyProperties) {
       return obj != null && getTypename(obj) === typename;
     }
 

package/src/internal/object/{create.test.ts → create-object.test.ts}

@@ -9,15 +9,14 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN } from '@dxos/keys';
 
-import { getSchemaDXN } from '../ast';
-import { Testing } from '../testing';
-import { isInstanceOf } from '../types';
+import { Relation } from '../../index';
+import { TestSchema } from '../../testing';
+import { getSchemaDXN, getTypeDXN, isInstanceOf } from '../annotations';
+import { ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET } from '../entities';
+import { ATTR_META, ATTR_TYPE, getSchema } from '../types';
 
-import { getSchema } from './accessors';
-import { create } from './create';
+import { createObject } from './create-object';
 import { objectToJSON } from './json-serializer';
-import { RelationSourceId, RelationTargetId } from './model';
-import { getType } from './typename';
 
 describe('create (static version)', () => {
   test('defaults', ({ expect }) => {
@@ -34,7 +33,7 @@ describe('create (static version)', () => {
   });
 
   test('create static object', () => {
-    const contact = create(Testing.Person, {
+    const contact = createObject(TestSchema.Person, {
       name: 'Bot',
       email: 'bot@example.com',
     });
@@ -43,12 +42,12 @@ describe('create (static version)', () => {
     expect(contact.name).toBe('Bot');
     expect(contact.email).toBe('bot@example.com');
     expect((contact as any)['@type']).toBeUndefined();
-    expect(getType(contact)?.toString()).toBe(getSchemaDXN(Testing.Person)!.toString());
-    expect(isInstanceOf(Testing.Person, contact)).toBe(true);
+    expect(getTypeDXN(contact)?.toString()).toBe(getSchemaDXN(TestSchema.Person)!.toString());
+    expect(isInstanceOf(TestSchema.Person, contact)).toBe(true);
   });
 
   test('JSON encoding', () => {
-    const contact = create(Testing.Person, {
+    const contact = createObject(TestSchema.Person, {
       name: 'Bot',
       email: 'bot@example.com',
     });
@@ -56,7 +55,7 @@ describe('create (static version)', () => {
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
       id: contact.id,
-      '@type': DXN.fromTypenameAndVersion(Testing.Person.typename, Testing.Person.version).toString(),
+      '@type': DXN.fromTypenameAndVersion(TestSchema.Person.typename, TestSchema.Person.version).toString(),
       '@meta': {
         keys: [],
       },
@@ -67,48 +66,47 @@ describe('create (static version)', () => {
   });
 
   test('JSON encoding with relation', () => {
-    const contactA = create(Testing.Person, {
-      name: 'Bot',
-      email: 'bot@example.com',
+    const person1 = createObject(TestSchema.Person, {
+      name: 'Alice',
+      email: 'alice@example.com',
     });
-    const contactB = create(Testing.Person, {
-      name: 'Bot',
-      email: 'bot@example.com',
+    const person2 = createObject(TestSchema.Person, {
+      name: 'Bob',
+      email: 'bob@example.com',
     });
-    const hasManager = create(Testing.HasManager, {
-      [RelationSourceId]: contactA,
-      [RelationTargetId]: contactB,
+
+    const manager = createObject(TestSchema.HasManager, {
+      [Relation.Source]: person1 as any,
+      [Relation.Target]: person2 as any,
     });
 
-    const json = JSON.parse(JSON.stringify(hasManager));
+    const json = JSON.parse(JSON.stringify(manager));
     expect(json).toEqual({
-      id: hasManager.id,
-      '@type': DXN.fromTypenameAndVersion(Testing.HasManager.typename, Testing.HasManager.version).toString(),
-      '@relationSource': DXN.fromLocalObjectId(contactA.id).toString(),
-      '@relationTarget': DXN.fromLocalObjectId(contactB.id).toString(),
-      '@meta': {
+      id: manager.id,
+      [ATTR_TYPE]: DXN.fromTypenameAndVersion(TestSchema.HasManager.typename, TestSchema.HasManager.version).toString(),
+      [ATTR_RELATION_SOURCE]: DXN.fromLocalObjectId(person1.id).toString(),
+      [ATTR_RELATION_TARGET]: DXN.fromLocalObjectId(person2.id).toString(),
+      [ATTR_META]: {
         keys: [],
       },
     });
   });
 
   test('getSchema', () => {
-    const contact = create(Testing.Person, {
+    const contact = createObject(TestSchema.Person, {
       name: 'Bot',
       email: 'bot@example.com',
     });
 
-    expect(getSchema(contact)).toBe(Testing.Person);
+    expect(getSchema(contact)).toBe(TestSchema.Person);
   });
 
   test('inspect', () => {
-    const contact = create(Testing.Person, {
+    const contact = createObject(TestSchema.Person, {
       name: 'Bot',
       email: 'bot@example.com',
     });
 
-    // console.log(contact);
-
     const text = inspect(contact);
     expect(text).toContain('Bot');
     expect(text).toContain('bot@example.com');

package/src/internal/object/{create.ts → create-object.ts}

@@ -7,33 +7,30 @@ 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 { EntityKind, getSchemaDXN, getTypeAnnotation } from '../ast';
-
-import { getObjectDXN, setSchema } from './accessors';
-import { attachedTypedObjectInspector } from './inspect';
-import { attachTypedJsonSerializer } from './json-serializer';
+import { getSchemaDXN, getTypeAnnotation, setTypename } from '../annotations';
 import {
-  EntityKindId,
-  MetaId,
   RelationSourceDXNId,
   RelationSourceId,
   RelationTargetDXNId,
   RelationTargetId,
-  assertObjectModelShape,
-} from './model';
-import { setTypename } from './typename';
+  assertObjectModel,
+  getObjectDXN,
+} from '../entities';
+import { defineHiddenProperty } from '../proxy';
+import { EntityKind, KindId, MetaId, setSchema } from '../types';
+
+import { attachedTypedObjectInspector } from './inspect';
+import { attachTypedJsonSerializer } from './json-serializer';
 
-// Make `id` optional.
-type CreateData<T> = T extends { id: string } ? Omit<T, 'id' | typeof EntityKindId> & { id?: string } : T;
+export type CreateObjectProps<T> = T extends { id: string } ? Omit<T, 'id' | KindId> & { id?: string } : T;
 
 /**
  * Creates a new object instance from a schema and data, without signal reactivity.
  * This static version creates plain JavaScript objects that are not reactive/observable.
  * For reactive objects that automatically update UI when changed, use the regular live() function.
  *
- * @param schema - The Effect schema that defines the object's structure and type, piped into EchoObject
+ * @param schema - The Effect schema that defines the object's structure and type, piped into EchoObjectSchema
  * @param data - The data to initialize the object with. The id and @type fields are handled automatically.
  * @returns A new non-reactive object instance conforming to the schema
  * @throws {Error} If the schema is not an object schema
@@ -44,53 +41,55 @@ type CreateData<T> = T extends { id: string } ? Omit<T, 'id' | typeof EntityKind
  * 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',
  * }))
  *
- * // Creates a non-reactive contact object
- * const contact = create(Contact, {
+ * const contact = createObject(Contact, {
  *   name: "John",
  *   email: "john@example.com",
  * })
  * ```
  */
-// TODO(burdon): Rename make.
-// TODO(burdon): Handle defaults (see Schema.make).
-// TODO(dmaretskyi): Use `Obj.make` and `Relation.make` from '@dxos/echo' instead.
-export const create = <S extends Schema.Schema.AnyNoContext>(
+// TODO(burdon): Make internal.
+export const createObject = <S extends Schema.Schema.AnyNoContext>(
   schema: S,
-  data: CreateData<Schema.Schema.Type<S>>,
-): CreateData<Schema.Schema.Type<S>> & { id: string } => {
+  props: CreateObjectProps<Schema.Schema.Type<S>>,
+): CreateObjectProps<Schema.Schema.Type<S>> & { id: string; [KindId]: EntityKind } => {
   const annotation = getTypeAnnotation(schema);
   if (!annotation) {
-    throw new Error('Schema is not an object schema');
+    throw new Error('Schema is not an ECHO schema');
   }
-  assertArgument(!('@type' in data), 'data', '@type is not allowed');
-  assertArgument(!(RelationSourceDXNId in data), 'data', 'Relation source DXN is not allowed in the constructor');
-  assertArgument(!(RelationTargetDXNId in data), 'data', 'Relation target DXN is not allowed in the constructor');
+  assertArgument(!('@type' in props), 'data', '@type is not allowed');
+  assertArgument(!(RelationSourceDXNId in props), 'data', 'Relation source DXN is not allowed in the constructor');
+  assertArgument(!(RelationTargetDXNId in props), 'data', 'Relation target DXN is not allowed in the constructor');
   assertArgument(
-    RelationSourceId in data === RelationTargetId in data,
+    RelationSourceId in props === RelationTargetId in props,
     'data',
     'Relation source and target must be provided together',
   );
 
-  const obj = { ...data, id: data.id ?? ObjectId.random() };
-  const kind = RelationSourceId in data ? EntityKind.Relation : EntityKind.Object;
-  defineHiddenProperty(obj, EntityKindId, kind);
-  setTypename(obj, getSchemaDXN(schema) ?? failedInvariant('Missing schema DXN'));
+  // Raw object.
+  const obj = { ...props, id: props.id ?? ObjectId.random() };
+
+  // Metadata.
+  const kind = RelationSourceId in props ? EntityKind.Relation : EntityKind.Object;
+  defineHiddenProperty(obj, KindId, kind);
+  defineHiddenProperty(obj, MetaId, { keys: [] });
   setSchema(obj, schema);
+  setTypename(obj, getSchemaDXN(schema) ?? failedInvariant('Missing schema DXN'));
   attachTypedJsonSerializer(obj);
   attachedTypedObjectInspector(obj);
-  defineHiddenProperty(obj, MetaId, { keys: [] });
+
+  // Relation.
   if (kind === EntityKind.Relation) {
-    const sourceDXN = getObjectDXN(data[RelationSourceId]) ?? raise(new Error('Unresolved relation source'));
-    const targetDXN = getObjectDXN(data[RelationTargetId]) ?? raise(new Error('Unresolved relation target'));
+    const sourceDXN = getObjectDXN(props[RelationSourceId]) ?? raise(new Error('Unresolved relation source'));
+    const targetDXN = getObjectDXN(props[RelationTargetId]) ?? raise(new Error('Unresolved relation target'));
     defineHiddenProperty(obj, RelationSourceDXNId, sourceDXN);
     defineHiddenProperty(obj, RelationTargetDXNId, targetDXN);
   }
 
-  assertObjectModelShape(obj);
+  assertObjectModel(obj);
   return obj;
 };

package/src/internal/object/deleted.ts

@@ -2,18 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import type { BaseObject } from '../types';
-
-import { DeletedId } from './model';
+import { ObjectDeletedId } from '../entities';
+import { type AnyProperties } from '../types';
 
 /**
  * @returns `true` if the object has been marked as deleted.
  */
-export const isDeleted = (obj: BaseObject): boolean => {
-  if ((obj as any)[DeletedId] === undefined) {
+export const isDeleted = (obj: AnyProperties): boolean => {
+  if ((obj as any)[ObjectDeletedId] === undefined) {
     // TODO(dmaretskyi): Return to prior behavior of throwing.
     // throw new Error('Object does not support deletion marker');
     return false;
   }
-  return (obj as any)[DeletedId] ?? false;
+
+  return (obj as any)[ObjectDeletedId] ?? false;
 };

package/src/internal/object/ids.ts

@@ -4,9 +4,9 @@
 
 import { DXN, ObjectId, QueueSubspaceTags, SpaceId } from '@dxos/keys';
 
-// TODO(burdon): Move to @dxos/keys once ObjectId is moved there.
 /**
  * @deprecated Use `db.queues.create()`
  */
+// TODO(burdon): Move to @dxos/keys.
 export const createQueueDXN = (spaceId = SpaceId.random(), queueId = ObjectId.random()) =>
   new DXN(DXN.kind.QUEUE, [QueueSubspaceTags.DATA, spaceId, queueId]);

package/src/internal/object/index.ts

@@ -3,17 +3,12 @@
 //
 
 export * from './common';
-export * from './create';
-export * from './entity';
-export * from './expando';
+export * from './create-object';
+export * from './deleted';
 export * from './ids';
 export * from './json-serializer';
-export * from './meta';
-export type * from './relation';
-export * from './typed-object';
-export * from './typename';
-export * from './deleted';
-export * from './model';
-export * from './accessors';
 export * from './schema-validator';
-export * from './version';
+export * from './set-value';
+export * from './snapshot';
+export * from './typed-object';
+export * from './clone';

package/src/internal/object/inspect.ts

@@ -6,10 +6,8 @@ import type { InspectOptionsStylized, inspect as inspectFn } from 'node:util';
 
 import { type CustomInspectFunction, inspectCustom } from '@dxos/debug';
 
-import { type AnyEchoObject } from '../types';
-
-import { ATTR_META, ATTR_TYPE, MetaId } from './model';
-import { getType } from './typename';
+import { getTypeDXN } from '../annotations';
+import { ATTR_META, ATTR_TYPE, type AnyEntity, MetaId } from '../types';
 
 /*
  * @internal
@@ -29,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,
@@ -39,7 +37,7 @@ const typedObjectInspectFunction: CustomInspectFunction<AnyEchoObject> = functio
   return inspect(
     {
       id,
-      [ATTR_TYPE]: getType(this),
+      [ATTR_TYPE]: getTypeDXN(this),
       ...props,
       [ATTR_META]: (this as any)[MetaId], // TODO(dmaretskyi): Couldn't use getMeta since that throw's if the object has no meta.
     },

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

@@ -6,26 +6,27 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN } from '@dxos/keys';
 
-import { EntityKind, getSchemaDXN, getSchemaTypename } from '../ast';
+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 { Testing } from '../testing';
+import { ATTR_TYPE, EntityKind, KindId, MetaId, TypeId, getSchema } from '../types';
 
-import { getObjectDXN, getSchema } from './accessors';
-import { create } from './create';
+import { createObject } from './create-object';
 import { objectFromJSON, objectToJSON } from './json-serializer';
-import { getMeta } from './meta';
-import { ATTR_TYPE, EntityKindId, MetaId, RelationSourceId, RelationTargetId, TypeId } from './model';
-import { getType, getTypename } from './typename';
 
 describe('Object JSON serializer', () => {
   test('should serialize and deserialize object', async () => {
-    const contact = create(Testing.Person, {
-      name: 'John Doe',
+    const contact = makeObject(TestSchema.Person, { name: 'Alice' });
+    Obj.change(contact, (c) => {
+      getMetaChecked(c).keys.push({ id: '12345', source: 'example.com' });
     });
-    getMeta(contact).keys.push({ id: '12345', source: 'crm.example.com' });
 
-    const task = create(Testing.Task, {
-      title: 'Polish my shoes',
+    const task = createObject(TestSchema.Task, {
+      title: 'Fix the tests',
       assignee: Ref.make(contact),
     });
 
@@ -33,67 +34,65 @@ describe('Object JSON serializer', () => {
     const taskJson = objectToJSON(task);
 
     expect(contactJson.id).toBe(contact.id);
-    expect(contactJson[ATTR_TYPE]).toEqual(getSchemaDXN(Testing.Person)!.toString());
-    expect(contactJson.name).toEqual('John Doe');
+    expect(contactJson[ATTR_TYPE]).toEqual(getSchemaDXN(TestSchema.Person)!.toString());
+    expect(contactJson.name).toEqual('Alice');
 
     expect(taskJson.id).toBe(task.id);
-    expect(taskJson[ATTR_TYPE]).toEqual(getSchemaDXN(Testing.Task)!.toString());
-    expect(taskJson.title).toEqual('Polish my shoes');
+    expect(taskJson[ATTR_TYPE]).toEqual(getSchemaDXN(TestSchema.Task)!.toString());
+    expect(taskJson.title).toEqual('Fix the tests');
     expect(taskJson.assignee).toEqual({ '/': DXN.fromLocalObjectId(contact.id).toString() });
 
     const refResolver = new StaticRefResolver()
-      .addSchema(Testing.Person)
-      .addSchema(Testing.Task)
+      .addSchema(TestSchema.Person)
+      .addSchema(TestSchema.Task)
       .addObject(contact)
       .addObject(task);
 
-    const contactFromJson = (await objectFromJSON(contactJson, { refResolver })) as Testing.Person;
-    const taskFromJson = (await objectFromJSON(taskJson, { refResolver })) as Testing.Task;
+    const contactFromJson = (await objectFromJSON(contactJson, { refResolver })) as TestSchema.Person;
+    const taskFromJson = (await objectFromJSON(taskJson, { refResolver })) as TestSchema.Task;
 
     expect(contactFromJson.id).toBe(contact.id);
-    expect(contactFromJson.name).toBe('John Doe');
-    expect((contactFromJson as any)[TypeId]).toEqual(getSchemaDXN(Testing.Person));
-    expect((contactFromJson as any)[EntityKindId]).toBe(EntityKind.Object);
+    expect(contactFromJson.name).toBe('Alice');
+    expect((contactFromJson as any)[TypeId]).toEqual(getSchemaDXN(TestSchema.Person));
+    expect((contactFromJson as any)[KindId]).toBe(EntityKind.Object);
     expect((contactFromJson as any)[RelationSourceId]).toBeUndefined();
     expect((contactFromJson as any)[RelationTargetId]).toBeUndefined();
     expect((contactFromJson as any)[MetaId]).toEqual({
       keys: [
         {
           id: '12345',
-          source: 'crm.example.com',
+          source: 'example.com',
         },
       ],
     });
-    expect(getType(contactFromJson)?.toString()).toBe(getSchemaDXN(Testing.Person)!.toString());
-    expect(getTypename(contactFromJson)).toBe(getSchemaTypename(Testing.Person));
+    expect(getTypeDXN(contactFromJson)?.toString()).toBe(getSchemaDXN(TestSchema.Person)!.toString());
+    expect(getTypename(contactFromJson)).toBe(getSchemaTypename(TestSchema.Person));
     expect(getObjectDXN(contactFromJson)?.toString()).toEqual(getObjectDXN(contact)?.toString());
-    expect(getSchema(contactFromJson)).toEqual(Testing.Person);
+    expect(getSchema(contactFromJson)).toEqual(TestSchema.Person);
 
     expect(taskFromJson.id).toBe(task.id);
-    expect(taskFromJson.title).toBe('Polish my shoes');
+    expect(taskFromJson.title).toBe('Fix the tests');
     expect(taskFromJson.assignee!.dxn).toEqual(DXN.fromLocalObjectId(contact.id));
     expect(taskFromJson.assignee!.target).toEqual(contact);
     expect(await taskFromJson.assignee!.load()).toEqual(contact);
-    expect((taskFromJson as any)[TypeId]).toEqual(getSchemaDXN(Testing.Task));
-    expect((taskFromJson as any)[EntityKindId]).toBe(EntityKind.Object);
+    expect((taskFromJson as any)[TypeId]).toEqual(getSchemaDXN(TestSchema.Task));
+    expect((taskFromJson as any)[KindId]).toBe(EntityKind.Object);
     expect((taskFromJson as any)[RelationSourceId]).toBeUndefined();
     expect((taskFromJson as any)[RelationTargetId]).toBeUndefined();
     expect((taskFromJson as any)[MetaId]).toEqual({ keys: [] });
-    expect(getSchema(taskFromJson)).toEqual(Testing.Task);
+    expect(getSchema(taskFromJson)).toEqual(TestSchema.Task);
   });
 
   test('serialize with unresolved schema', async () => {
-    const contact = create(Testing.Person, {
-      name: 'John Doe',
-    });
+    const contact = createObject(TestSchema.Person, { name: 'Alice' });
     const contactJson = objectToJSON(contact);
     const contactFromJson: any = await objectFromJSON(contactJson);
 
     expect(contactFromJson.id).toBe(contact.id);
-    expect(contactFromJson.name).toBe('John Doe');
+    expect(contactFromJson.name).toBe('Alice');
     expect(getSchema(contactFromJson)).toBeUndefined();
-    expect(getTypename(contactFromJson)).toEqual(getSchemaTypename(Testing.Person));
+    expect(getTypename(contactFromJson)).toEqual(getSchemaTypename(TestSchema.Person));
     expect(getObjectDXN(contactFromJson)).toEqual(getObjectDXN(contact));
-    expect(getType(contactFromJson)).toEqual(getSchemaDXN(Testing.Person));
+    expect(getTypeDXN(contactFromJson)).toEqual(getSchemaDXN(TestSchema.Person));
   });
 });