@dxos/echo 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

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

@@ -11,42 +11,51 @@ import { DXN, ObjectId } from '@dxos/keys';
 import { defineHiddenProperty } from '@dxos/live-object';
 import { assumeType, deepMapValues, visitValues } from '@dxos/util';
 
-import { EntityKind } from '../ast';
-import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../ref';
-import { type AnyEchoObject } from '../types';
-
-import { setSchema } from './accessors';
-import { ObjectMetaSchema } from './meta';
+import { getTypeDXN, setTypename } from '../annotations';
 import {
   ATTR_DELETED,
-  ATTR_META,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
   ATTR_SELF_DXN,
-  ATTR_TYPE,
-  EntityKindId,
-  MetaId,
   type ObjectJSON,
   RelationSourceDXNId,
   RelationSourceId,
   RelationTargetDXNId,
   RelationTargetId,
   SelfDXNId,
+  assertObjectModel,
+} from '../entities';
+import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../ref';
+import {
+  ATTR_META,
+  ATTR_TYPE,
+  type AnyEchoObject,
+  EntityKind,
+  KindId,
+  MetaId,
+  ObjectMetaSchema,
   TypeId,
-  assertObjectModelShape,
-} from './model';
-import { getType, setTypename } from './typename';
+  setSchema,
+} from '../types';
 
 type DeepReplaceRef<T> =
-  T extends Ref<any> ? EncodedReference : T extends object ? { [K in keyof T]: DeepReplaceRef<T[K]> } : T;
-
-type SerializedObject<T extends { id: string }> = { [K in keyof T]: DeepReplaceRef<T[K]> } & ObjectJSON;
+  T extends Ref<any>
+    ? EncodedReference
+    : T extends object
+      ? {
+          [K in keyof T]: DeepReplaceRef<T[K]>;
+        }
+      : T;
+
+type SerializedObject<T extends { id: string }> = {
+  [K in keyof T]: DeepReplaceRef<T[K]>;
+} & ObjectJSON;
 
 /**
  * Converts object to it's JSON representation.
  */
 export const objectToJSON = <T extends AnyEchoObject>(obj: T): SerializedObject<T> => {
-  const typename = getType(obj)?.toString();
+  const typename = getTypeDXN(obj)?.toString();
   invariant(typename && typeof typename === 'string');
   return typedJsonSerializer.call(obj);
 };
@@ -55,7 +64,6 @@ export const objectToJSON = <T extends AnyEchoObject>(obj: T): SerializedObject<
  * Creates an object from it's json representation.
  * Performs schema validation.
  * References and schema will be resolvable if the `refResolver` is provided.
- *
  * The function need to be async to support resolving the schema as well as the relation endpoints.
  */
 export const objectFromJSON = async (
@@ -82,7 +90,6 @@ export const objectFromJSON = async (
   }
 
   invariant(ObjectId.isValid(obj.id), 'Invalid object id');
-
   setTypename(obj, type);
   if (schema) {
     setSchema(obj, schema);
@@ -94,25 +101,21 @@ 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')));
 
-    // TODO(dmaretskyi): Async!
     const source = (await refResolver?.resolve(sourceDxn)) as AnyEchoObject | undefined;
     const target = (await refResolver?.resolve(targetDxn)) as AnyEchoObject | undefined;
 
-    defineHiddenProperty(obj, EntityKindId, EntityKind.Relation);
+    defineHiddenProperty(obj, KindId, EntityKind.Relation);
     defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
     defineHiddenProperty(obj, RelationTargetDXNId, targetDxn);
     defineHiddenProperty(obj, RelationSourceId, source);
     defineHiddenProperty(obj, RelationTargetId, target);
   } else {
-    defineHiddenProperty(obj, EntityKindId, EntityKind.Object);
+    defineHiddenProperty(obj, KindId, EntityKind.Object);
   }
 
   if (typeof jsonData[ATTR_META] === 'object') {
     const meta = await ObjectMetaSchema.pipe(Schema.decodeUnknownPromise)(jsonData[ATTR_META]);
-
-    // Defensive programming.
     invariant(Array.isArray(meta.keys));
-
     defineHiddenProperty(obj, MetaId, meta);
   }
 
@@ -120,13 +123,13 @@ export const objectFromJSON = async (
     defineHiddenProperty(obj, SelfDXNId, dxn);
   }
 
-  assertObjectModelShape(obj);
+  assertObjectModel(obj);
   invariant((obj as any)[ATTR_TYPE] === undefined, 'Invalid object model');
-  invariant((obj as any)[ATTR_SELF_DXN] === undefined, 'Invalid object model');
+  invariant((obj as any)[ATTR_META] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_DELETED] === undefined, 'Invalid object model');
+  invariant((obj as any)[ATTR_SELF_DXN] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_RELATION_SOURCE] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_RELATION_TARGET] === undefined, 'Invalid object model');
-  invariant((obj as any)[ATTR_META] === undefined, 'Invalid object model');
   return obj;
 };
 
@@ -135,30 +138,31 @@ const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }
     [ATTR_TYPE]: _type,
     [ATTR_META]: _meta,
     [ATTR_DELETED]: _deleted,
+    [ATTR_SELF_DXN]: _selfDxn,
     [ATTR_RELATION_SOURCE]: _relationSource,
     [ATTR_RELATION_TARGET]: _relationTarget,
-    [ATTR_SELF_DXN]: _selfDxn,
     ...props
   } = jsonData as any;
 
-  return deepMapValues(props, (value, recurse) => {
+  return deepMapValues(props, (value, visitor) => {
     if (isEncodedReference(value)) {
       return refFromEncodedReference(value, options.refResolver);
     }
-    return recurse(value);
+
+    return visitor(value);
   });
 };
 
 export const setRefResolverOnData = (obj: AnyEchoObject, refResolver: RefResolver) => {
-  const go = (value: unknown) => {
+  const visitor = (value: unknown) => {
     if (Ref.isRef(value)) {
       setRefResolver(value, refResolver);
     } else {
-      visitValues(value, go);
+      visitValues(value, visitor);
     }
   };
 
-  go(obj);
+  visitor(obj);
 };
 
 export const attachTypedJsonSerializer = (obj: any) => {
@@ -187,6 +191,10 @@ const typedJsonSerializer = function (this: any) {
     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();
   }
@@ -202,10 +210,6 @@ const typedJsonSerializer = function (this: any) {
     result[ATTR_RELATION_TARGET] = targetDXN.toString();
   }
 
-  if (this[MetaId]) {
-    result[ATTR_META] = serializeMeta(this[MetaId]);
-  }
-
   Object.assign(result, serializeData(rest));
   return result;
 };
@@ -216,6 +220,7 @@ const serializeData = (data: unknown) => {
       // TODO(dmaretskyi): Should this be configurable?
       return value.noInline().encode();
     }
+
     return recurse(value);
   });
 };

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

@@ -7,7 +7,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 
 import { invariant } from '@dxos/invariant';
 
-import { SchemaId } from './model';
+import { SchemaId } from '../types';
 
 // TODO(burdon): Reconcile with @dxos/effect visit().
 
@@ -46,7 +46,7 @@ export class SchemaValidator {
       }
 
       return type.ast.annotations[annotation] != null;
-    } catch (err) {
+    } catch {
       return false;
     }
   }
@@ -238,4 +238,5 @@ export const checkIdNotPresentOnSchema = (schema: Schema.Schema<any, any, any>)
   }
 };
 
+// TODO(burdon): Reconcile with JsonPath.
 type KeyPath = readonly (string | number)[];

package/src/internal/object/typed-object.test.ts

@@ -15,7 +15,7 @@ class Organization extends TypedObject({
   name: Schema.String,
 }) {}
 
-describe('EchoObject class DSL', () => {
+describe('EchoObjectSchema class DSL', () => {
   test('type is a valid schema', async () => {
     expect(Schema.isSchema(Organization)).to.be.true;
   });

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

@@ -7,11 +7,17 @@ import * as SchemaAST from 'effect/SchemaAST';
 
 import { invariant } from '@dxos/invariant';
 
-import { EntityKind, SchemaVersion, type TypeAnnotation, TypeAnnotationId, type TypeMeta, Typename } from '../ast';
-import { type HasId } from '../types';
+import {
+  type TypeAnnotation,
+  TypeAnnotationId,
+  type TypeMeta,
+  TypenameSchema,
+  VersionSchema,
+  makeTypeJsonSchemaAnnotation,
+} from '../annotations';
+import { EntityKind, type HasId } from '../types';
 
 import { type TypedObjectFields, type TypedObjectOptions, makeTypedEntityClass } from './common';
-import { makeTypeJsonSchemaAnnotation } from './entity';
 
 /**
  * Definition for an object type that can be stored in an ECHO database.
@@ -46,8 +52,8 @@ export const TypedObject = ({
   version: versionParam,
   disableValidation,
 }: TypedObjectProps) => {
-  const typename = Typename.make(typenameParam, { disableValidation });
-  const version = SchemaVersion.make(versionParam, { disableValidation });
+  const typename = TypenameSchema.make(typenameParam, { disableValidation });
+  const version = VersionSchema.make(versionParam, { disableValidation });
 
   /**
    * Return class definition factory.

package/src/internal/proxy/handler.test.ts

@@ -7,29 +7,39 @@ import { inspect } from 'node:util';
 import { describe, expect, test } from 'vitest';
 
 import { registerSignalsRuntime } from '@dxos/echo-signals';
-import type { Live } from '@dxos/live-object';
-import { objectData } from '@dxos/live-object';
+import { type Live, objectData } from '@dxos/live-object';
 import { isNode } from '@dxos/util';
 
-import { ATTR_META } from '..';
-import { Testing, updateCounter } from '../testing';
+import { TestSchema, updateCounter } from '../../testing';
+import { createObject } from '../object';
+import { ATTR_META } from '../types';
 
-import { live } from './reactive-object';
+import { makeObject } from './make-object';
 
 registerSignalsRuntime();
 
-const TEST_OBJECT: Testing.TestSchema = {
+describe('proxy', () => {
+  test.skipIf(!isNode())('inspect', ({ expect }) => {
+    const obj = createObject(TestSchema.Message, { timestamp: new Date().toISOString() });
+    const str = inspect(obj, { colors: true });
+    expect(str).to.exist;
+  });
+});
+
+const TEST_OBJECT: TestSchema.ExampleSchema = {
   string: 'foo',
   number: 42,
   boolean: true,
   null: null,
   stringArray: ['1', '2', '3'],
-  object: { field: 'bar' },
+  nested: {
+    field: 'bar',
+  },
 };
 
-for (const schema of [undefined, Testing.TestSchemaWithClass]) {
-  const createObject = (props: Partial<Testing.TestSchemaWithClass> = {}): Live<Testing.TestSchemaWithClass> => {
-    return schema == null ? (live(props) as Testing.TestSchemaWithClass) : live(schema, props);
+for (const schema of [undefined, TestSchema.ExampleSchema]) {
+  const createObject = (props: Partial<TestSchema.ExampleSchema> = {}): Live<TestSchema.ExampleSchema> => {
+    return schema == null ? (makeObject(props) as TestSchema.ExampleSchema) : makeObject(schema, props);
   };
 
   describe(`Non-echo specific proxy properties${schema == null ? '' : ' with schema'}`, () => {
@@ -51,10 +61,10 @@ for (const schema of [undefined, Testing.TestSchemaWithClass]) {
     test('can assign class instances', () => {
       const obj = createObject();
 
-      const classInstance = new Testing.TestClass();
+      const classInstance = new TestSchema.TestClass();
       obj.classInstance = classInstance;
       expect(obj.classInstance!.field).to.eq('value');
-      expect(obj.classInstance instanceof Testing.TestClass).to.eq(true);
+      expect(obj.classInstance instanceof TestSchema.TestClass).to.eq(true);
       expect(obj.classInstance === classInstance).to.be.true;
 
       obj.classInstance!.field = 'baz';
@@ -63,7 +73,7 @@ for (const schema of [undefined, Testing.TestSchemaWithClass]) {
 
     describe('class instance equality', () => {
       test('toJSON', () => {
-        const original = { classInstance: new Testing.TestClass() };
+        const original = { classInstance: new TestSchema.TestClass() };
         const reactive = createObject(original);
         if (!schema) {
           expect(JSON.stringify(reactive)).to.eq(JSON.stringify(original));
@@ -80,14 +90,14 @@ for (const schema of [undefined, Testing.TestSchemaWithClass]) {
       });
 
       test('chai deep equal works', () => {
-        const original = { classInstance: new Testing.TestClass() };
+        const original = { classInstance: new TestSchema.TestClass() };
         const reactive = createObject(original);
         expect(reactive).to.deep.eq(original);
         expect(reactive).to.not.deep.eq({ ...original, number: 11 });
       });
 
       test('jest deep equal works', () => {
-        const original = { classInstance: new Testing.TestClass() };
+        const original = { classInstance: new TestSchema.TestClass() };
         const reactive = createObject(original);
         expect(reactive).toEqual(original);
         expect(reactive).not.toEqual({ ...original, number: 11 });
@@ -96,7 +106,7 @@ for (const schema of [undefined, Testing.TestSchemaWithClass]) {
 
     describe('signal updates', () => {
       test('not in nested class instances', () => {
-        const obj = createObject({ classInstance: new Testing.TestClass() });
+        const obj = createObject({ classInstance: new TestSchema.TestClass() });
         using updates = updateCounter(() => {
           obj.classInstance!.field;
         });
@@ -112,7 +122,7 @@ for (const schema of [undefined, Testing.TestSchemaWithClass]) {
 describe('getters', () => {
   test('add getter to object', () => {
     let value = 'foo';
-    const obj = live({
+    const obj = makeObject({
       get getter() {
         return value;
       },
@@ -124,11 +134,11 @@ describe('getters', () => {
   });
 
   test('signal updates', () => {
-    const innerObj = live({
+    const innerObj = makeObject({
       string: 'bar',
     });
 
-    const obj = live({
+    const obj = makeObject({
       field: 1,
       get getter() {
         return innerObj.string;
@@ -150,7 +160,7 @@ describe('getters', () => {
 
   test('getter for array', () => {
     const value = [1];
-    const obj = live({
+    const obj = makeObject({
       get getter() {
         return value;
       },

package/src/internal/proxy/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './make-object';
+export * from './typed-handler';

package/src/internal/proxy/{reactive-object.ts → make-object.ts}

@@ -13,32 +13,37 @@ import {
   isValidProxyTarget,
 } from '@dxos/live-object';
 
-import { getTypeAnnotation } from '../ast';
-import { EntityKindId, Expando, MetaId, type ObjectMeta, ObjectMetaSchema, attachTypedJsonSerializer } from '../object';
-import type { BaseObject, CreationProps } from '../types';
+import { getTypeAnnotation } from '../annotations';
+import { Expando } from '../entities';
+import { attachTypedJsonSerializer } from '../object';
+import { type AnyProperties, KindId, MetaId, type ObjectMeta, ObjectMetaSchema } from '../types';
 
 import { TypedReactiveHandler, prepareTypedTarget } from './typed-handler';
 
+/**
+ *
+ */
+// TODO(burdon): Make internal
+export type MakeObjectProps<T extends AnyProperties> = Omit<T, 'id' | KindId>;
+
 /**
  * Creates a reactive object from a plain Javascript object.
  * Optionally provides a TS-effect schema.
- *
- * @depreacted Use `Obj.make`.
  */
+// TODO(burdon): Make internal
 // TODO(dmaretskyi): Deep mutability.
 // TODO(dmaretskyi): Invert generics (generic over schema) to have better error messages.
 // TODO(dmaretskyi): Could mutate original object making it unusable.
-// TODO(burdon): Use Schema.make() to handle defaults?
-export const live: {
-  <T extends BaseObject>(obj: T): Live<T>;
-  <T extends BaseObject>(
+export const makeObject: {
+  <T extends AnyProperties>(obj: T): Live<T>;
+  <T extends AnyProperties>(
     schema: Schema.Schema<T, any, never>,
-    obj: NoInfer<CreationProps<T>>,
+    obj: NoInfer<MakeObjectProps<T>>,
     meta?: ObjectMeta,
   ): Live<T>;
-} = <T extends BaseObject>(
+} = <T extends AnyProperties>(
   objOrSchema: Schema.Schema<T, any> | T,
-  obj?: CreationProps<T>,
+  obj?: MakeObjectProps<T>,
   meta?: ObjectMeta,
 ): Live<T> => {
   // TODO(dmaretskyi): Remove Expando special case.
@@ -51,7 +56,7 @@ export const live: {
   }
 };
 
-const createReactiveObject = <T extends BaseObject>(
+const createReactiveObject = <T extends AnyProperties>(
   obj: T,
   meta?: ObjectMeta,
   schema?: Schema.Schema<T>,
@@ -68,7 +73,7 @@ const createReactiveObject = <T extends BaseObject>(
       setIdOnTarget(obj);
     }
     if (annotation) {
-      defineHiddenProperty(obj, EntityKindId, annotation.kind);
+      defineHiddenProperty(obj, KindId, annotation.kind);
     }
     initMeta(obj, meta);
     prepareTypedTarget(obj, schema);

package/src/internal/proxy/schema.test.ts

@@ -6,8 +6,9 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
-import { PropertyMeta, TypedObject, getPropertyMetaAnnotation, getTypeAnnotation } from '..';
-import { createEchoSchema } from '../../testing/echo-schema';
+import { createEchoSchema } from '../../testing';
+import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../annotations';
+import { TypedObject } from '../object';
 
 // TODO(dmaretskyi): Comment.
 class EmptySchemaType extends TypedObject({
@@ -95,7 +96,7 @@ describe('dynamic schema', () => {
   test('updates typename', async ({ expect }) => {
     // Create schema with some fields and annotations.
     const registered = createEchoSchema(EmptySchemaType);
-    const originalVersion = registered.storedSchema.version;
+    const originalVersion = registered.persistentSchema.version;
     registered.addFields({
       name: Schema.String.pipe(PropertyMeta('test', { maxLength: 10 })),
       age: Schema.Number,
@@ -111,7 +112,7 @@ describe('dynamic schema', () => {
     expect(registered.jsonSchema.typename).toBe(newTypename1);
 
     // Version preservation check.
-    expect(registered.storedSchema.version).toBe(originalVersion);
+    expect(registered.persistentSchema.version).toBe(originalVersion);
 
     // Field preservation check.
     const properties = registered.getProperties();

package/src/internal/proxy/typed-handler.test.ts

@@ -5,10 +5,13 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { Ref, TypedObject, create, foreignKey, getMeta, getSchema, isInstanceOf } from '..';
-import { Testing } from '../testing';
+import { TestSchema } from '../../testing';
+import { isInstanceOf } from '../annotations';
+import { TypedObject, createObject } from '../object';
+import { Ref } from '../ref';
+import { foreignKey, getMeta, getSchema } from '../types';
 
-import { live } from './reactive-object';
+import { makeObject } from './make-object';
 
 describe('complex schema validations', () => {
   const setValue = (target: any, prop: string, value: any) => {
@@ -17,20 +20,20 @@ describe('complex schema validations', () => {
 
   test('any', () => {
     const schema = Schema.Struct({ field: Schema.Any });
-    const object = live(schema, { field: { nested: { value: 100 } } });
+    const object = makeObject(schema, { field: { nested: { value: 100 } } });
     expect(() => setValue(object, 'field', { any: 'value' })).not.to.throw();
   });
 
   test('meta', () => {
     const source = 'test';
     const schema = Schema.Struct({ field: Schema.Number });
-    const object = live(schema, { field: 42 }, { keys: [foreignKey(source, '123')] });
+    const object = makeObject(schema, { field: 42 }, { keys: [foreignKey(source, '123')] });
     expect(getMeta(object).keys).to.deep.eq([foreignKey(source, '123')]);
   });
 
   test('object', () => {
     const schema = Schema.Struct({ field: Schema.optional(Schema.Object) });
-    const object = live(schema, { field: { nested: { value: 100 } } });
+    const object = makeObject(schema, { field: { nested: { value: 100 } } });
     expect(() => setValue(object, 'field', { any: 'value' })).not.to.throw();
   });
 
@@ -38,15 +41,15 @@ describe('complex schema validations', () => {
     class Foo extends TypedObject({ typename: 'example.com/type/Foo', version: '0.1.0' })({ field: Schema.String }) {}
     class Bar extends TypedObject({ typename: 'example.com/type/Bar', version: '0.1.0' })({ fooRef: Ref(Foo) }) {}
     const field = 'hello';
-    expect(() => live(Bar, { fooRef: { id: '1', field } as any })).to.throw();
-    expect(() => live(Bar, { fooRef: undefined as any })).to.throw(); // Unresolved reference.
-    const bar = live(Bar, { fooRef: Ref.make(live(Foo, { field })) });
+    expect(() => makeObject(Bar, { fooRef: { id: '1', field } as any })).to.throw();
+    expect(() => makeObject(Bar, { fooRef: undefined as any })).to.throw(); // Unresolved reference.
+    const bar = makeObject(Bar, { fooRef: Ref.make(makeObject(Foo, { field })) });
     expect(bar.fooRef.target?.field).to.eq(field);
   });
 
   test('index signatures', () => {
     const schema = Schema.Struct({}, { key: Schema.String, value: Schema.Number });
-    const object = live(schema, { unknownField: 1 });
+    const object = makeObject(schema, { unknownField: 1 });
     expect(() => setValue(object, 'field', '42')).to.throw();
     expect(() => setValue(object, 'unknown_field', 42)).not.to.throw();
   });
@@ -57,7 +60,7 @@ describe('complex schema validations', () => {
       object: Schema.optional(Schema.suspend(() => Schema.Union(Schema.Null, Schema.Struct({ field: Schema.Number })))),
     });
 
-    const object = live(schema, { array: [1, 2, null], object: { field: 3 } });
+    const object = makeObject(schema, { array: [1, 2, null], object: { field: 3 } });
     expect(() => setValue(object, 'object', { field: 4 })).not.to.throw();
     expect(() => setValue(object.object, 'field', 4)).not.to.throw();
     expect(() => setValue(object.array, '0', 4)).not.to.throw();
@@ -65,38 +68,35 @@ describe('complex schema validations', () => {
   });
 
   test('nesting static objects with schema in the live object', () => {
-    const contact1 = create(Testing.Person, {
+    const contact1 = createObject(TestSchema.Person, {
       name: 'Robert Smith',
       email: 'robert@example.com',
     } as any);
-    const contact2 = create(Testing.Person, {
+    const contact2 = createObject(TestSchema.Person, {
       name: 'Katy Perry',
       email: 'katy@example.com',
     } as any);
 
-    const contactBook = live({
-      contacts: [contact1],
-    });
-
-    expect(isInstanceOf(Testing.Person, contactBook.contacts[0])).to.eq(true);
-    expect(getSchema(contactBook.contacts[0])).to.eq(Testing.Person);
+    const network = makeObject({ contacts: [contact1] });
+    expect(isInstanceOf(TestSchema.Person, network.contacts[0])).to.eq(true);
+    expect(getSchema(network.contacts[0])).to.eq(TestSchema.Person);
 
-    contactBook.contacts.push(contact2);
-    expect(isInstanceOf(Testing.Person, contactBook.contacts[1])).to.eq(true);
-    expect(getSchema(contactBook.contacts[1])).to.eq(Testing.Person);
+    network.contacts.push(contact2);
+    expect(isInstanceOf(TestSchema.Person, network.contacts[1])).to.eq(true);
+    expect(getSchema(network.contacts[1])).to.eq(TestSchema.Person);
   });
 
   test('creating an object with data from another object', () => {
-    const contact = live(Testing.Person, {
+    const contact = makeObject(TestSchema.Person, {
       name: 'Robert Smith',
       email: 'robert@example.com',
     });
-    const TestSchema = Schema.Struct({
-      value: Schema.Unknown,
-    });
-    const data = live(TestSchema, {
+
+    const TempSchema = Schema.Struct({ value: Schema.Unknown });
+    const object = makeObject(TempSchema, {
       value: contact,
     });
-    expect((data.value as any).name).to.eq('Robert Smith');
+
+    expect((object.value as any).name).to.eq('Robert Smith');
   });
 });

package/src/internal/proxy/typed-handler.ts

@@ -20,8 +20,10 @@ import {
   symbolIsProxy,
 } from '@dxos/live-object';
 
-import { getSchemaDXN } from '../ast';
-import { DeletedId, SchemaId, SchemaValidator, TypeId } from '../object';
+import { getSchemaDXN } from '../annotations';
+import { ObjectDeletedId } from '../entities';
+import { SchemaValidator } from '../object';
+import { SchemaId, TypeId } from '../types';
 
 const symbolSignal = Symbol('signal');
 const symbolPropertySignal = Symbol('property-signal');
@@ -68,7 +70,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
       defineHiddenProperty(target, symbolPropertySignal, compositeRuntime.createSignal());
     }
 
-    defineHiddenProperty(target, DeletedId, false);
+    defineHiddenProperty(target, ObjectDeletedId, false);
 
     for (const key of Object.getOwnPropertyNames(target)) {
       const descriptor = Object.getOwnPropertyDescriptor(target, key)!;
@@ -90,6 +92,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
 
   get(target: ProxyTarget, prop: string | symbol, receiver: any): any {
     switch (prop) {
+      // TODO(burdon): Remove?
       case objectData: {
         target[symbolSignal].notifyRead();
         return toJSON(target);
@@ -170,6 +173,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
       showHidden: false,
       customInspect: false,
     });
+
     return `Typed ${inspected}`;
   }
 }
@@ -177,6 +181,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
 /**
  * @deprecated Use `Obj.toJSON` instead.
  */
+// TODO(burdon): Remove?
 const toJSON = (target: ProxyTarget): any => {
   return { '@type': 'TypedReactiveObject', ...target };
 };