@dxos/echo 0.8.4-main.5ad4a44 → 0.8.4-main.66e292d

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

@@ -6,26 +6,23 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN } from '@dxos/keys';
 
-import { EntityKind, getSchemaDXN, getSchemaTypename } from '../ast';
+import { TestSchema } from '../../testing';
+import { getSchemaDXN, getSchemaTypename, getTypeDXN, getTypename } from '../annotations';
+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, getMeta, 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.Contact, {
-      name: 'John Doe',
-    });
-    getMeta(contact).keys.push({ id: '12345', source: 'crm.example.com' });
+    const contact = makeObject(TestSchema.Person, { name: 'Alice' });
+    getMeta(contact).keys.push({ id: '12345', source: '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 +30,65 @@ describe('Object JSON serializer', () => {
     const taskJson = objectToJSON(task);
 
     expect(contactJson.id).toBe(contact.id);
-    expect(contactJson[ATTR_TYPE]).toEqual(getSchemaDXN(Testing.Contact)!.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.Contact)
-      .addSchema(Testing.Task)
+      .addSchema(TestSchema.Person)
+      .addSchema(TestSchema.Task)
       .addObject(contact)
       .addObject(task);
 
-    const contactFromJson = (await objectFromJSON(contactJson, { refResolver })) as Testing.Contact;
-    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.Contact));
-    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.Contact)!.toString());
-    expect(getTypename(contactFromJson)).toBe(getSchemaTypename(Testing.Contact));
+    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.Contact);
+    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.Contact, {
-      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.Contact));
+    expect(getTypename(contactFromJson)).toEqual(getSchemaTypename(TestSchema.Person));
     expect(getObjectDXN(contactFromJson)).toEqual(getObjectDXN(contact));
-    expect(getType(contactFromJson)).toEqual(getSchemaDXN(Testing.Contact));
+    expect(getTypeDXN(contactFromJson)).toEqual(getSchemaDXN(TestSchema.Person));
   });
 });

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

@@ -3,11 +3,19 @@
 //
 
 import * as Schema from 'effect/Schema';
+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';
 
@@ -44,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.
@@ -69,6 +77,11 @@ export const TypedObject = ({
     invariant(typeof EntityKind.Object === 'string');
     const annotatedSchema = typeSchema.annotations({
       [TypeAnnotationId]: { kind: EntityKind.Object, typename, version } satisfies TypeAnnotation,
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Object,
+        typename,
+        version,
+      }),
     });
 
     /**

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();