@dxos/echo 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/src/internal/common/proxy/change.test.ts

@@ -4,16 +4,24 @@
 
 import { describe, test } from 'vitest';
 
+import { URI } from '@dxos/keys';
+
 import * as Obj from '../../../Obj';
+import * as Ref from '../../../Ref';
 import * as Relation from '../../../Relation';
 import { TestSchema } from '../../../testing';
 
+// Tags are stored as `Ref<Tag>`; build refs from synthetic URIs and compare by `.uri`.
+const tagRef = (id: string): Ref.Ref<any> => Ref.fromURI(URI.make(`dxn:echo:BBBBBBBBBBBBBBBBBBBBBBBBBB:${id}`));
+const tagUris = (entity: Obj.Unknown | Relation.Unknown): string[] =>
+  Obj.getMeta(entity as Obj.Unknown).tags.map((tag) => tag.uri);
+
 /**
  * Tests for Obj.update context enforcement and mutator type safety.
  *
  * These tests verify:
  * 1. Mutator functions require Mutable<T> at compile-time.
- * 2. getMeta returns ReadonlyMeta outside change callbacks and ObjectMeta inside.
+ * 2. getMeta returns ReadonlyMeta outside change callbacks and EntityMeta inside.
  * 3. Mutations outside Obj.update throw at runtime.
  * 4. Nested object/property mutations work correctly.
  * 5. Array mutations (push, pop, splice) require change context.
@@ -44,7 +52,7 @@ describe('Obj.update enforcement', () => {
 
       // No compile-time error: TypeScript's structural typing allows readonly objects
       // to be passed to Mutable<T> parameters. Enforcement is runtime-only.
-      expect(() => Obj.addTag(obj, 'tag')).toThrow(/outside of Obj.update/);
+      expect(() => Obj.addTag(obj, tagRef('tag'))).toThrow(/outside of Obj.update/);
     });
 
     test('getMeta mutation outside change throws', ({ expect }) => {
@@ -53,22 +61,22 @@ describe('Obj.update enforcement', () => {
 
       // Runtime errors for direct meta mutations.
       expect(() => ((meta as any).keys = [])).toThrow(/outside of Obj.update/);
-      expect(() => ((meta as any).tags = ['tag'])).toThrow(/outside of Obj.update/);
+      expect(() => ((meta as any).tags = [tagRef('tag')])).toThrow(/outside of Obj.update/);
     });
 
-    test('getMeta returns mutable ObjectMeta inside change callback', ({ expect }) => {
+    test('getMeta returns mutable EntityMeta inside change callback', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
       Obj.update(obj, (obj) => {
         const meta = Obj.getMeta(obj);
 
-        // These should compile without errors because meta is ObjectMeta (mutable).
+        // These should compile without errors because meta is EntityMeta (mutable).
         meta.keys = [];
-        meta.tags = ['tag'];
+        meta.tags = [tagRef('tag')];
         meta.keys.push({ source: 'test', id: '123' });
       });
 
-      expect(Obj.getMeta(obj).tags).toEqual(['tag']);
+      expect(tagUris(obj)).toEqual([tagRef('tag').uri]);
       expect(Obj.getMeta(obj).keys).toHaveLength(1);
     });
 
@@ -77,12 +85,12 @@ describe('Obj.update enforcement', () => {
 
       // These should compile without errors inside change callback.
       Obj.update(obj, (obj) => {
-        Obj.addTag(obj, 'my-tag');
+        Obj.addTag(obj, tagRef('my-tag'));
         Obj.setValue(obj, ['name'], 'Updated');
       });
 
       expect(obj.name).toBe('Updated');
-      expect(Obj.getMeta(obj).tags).toContain('my-tag');
+      expect(tagUris(obj)).toContain(tagRef('my-tag').uri);
     });
 
     test('Relation property mutation outside change throws', ({ expect }) => {
@@ -110,7 +118,7 @@ describe('Obj.update enforcement', () => {
 
       // No compile-time error: TypeScript's structural typing allows readonly objects
       // to be passed to Mutable<T> parameters. Enforcement is runtime-only.
-      expect(() => Relation.addTag(rel, 'tag')).toThrow(/outside of Obj.update/);
+      expect(() => Relation.addTag(rel, tagRef('tag'))).toThrow(/outside of Obj.update/);
     });
   });
 
@@ -151,20 +159,20 @@ describe('Obj.update enforcement', () => {
     test('addTag and removeTag work correctly', ({ expect }) => {
       const obj = Obj.make(TestSchema.Person, { name: 'Test' });
 
-      expect(Obj.getMeta(obj).tags).toBeUndefined();
+      expect(Obj.getMeta(obj).tags).toEqual([]);
 
       Obj.update(obj, (obj) => {
-        Obj.addTag(obj, 'tag-1');
-        Obj.addTag(obj, 'tag-2');
+        Obj.addTag(obj, tagRef('tag-1'));
+        Obj.addTag(obj, tagRef('tag-2'));
       });
 
-      expect(Obj.getMeta(obj).tags).toEqual(['tag-1', 'tag-2']);
+      expect(tagUris(obj)).toEqual([tagRef('tag-1').uri, tagRef('tag-2').uri]);
 
       Obj.update(obj, (obj) => {
-        Obj.removeTag(obj, 'tag-1');
+        Obj.removeTag(obj, tagRef('tag-1'));
       });
 
-      expect(Obj.getMeta(obj).tags).toEqual(['tag-2']);
+      expect(tagUris(obj)).toEqual([tagRef('tag-2').uri]);
     });
 
     test('deleteKeys removes foreign keys by source', ({ expect }) => {
@@ -202,12 +210,12 @@ describe('Obj.update enforcement', () => {
 
       Obj.update(obj, (obj) => {
         const meta = Obj.getMeta(obj);
-        meta.tags = ['tag-1', 'tag-2'];
+        meta.tags = [tagRef('tag-1'), tagRef('tag-2')];
         meta.keys.push({ source: 'external', id: '123' });
       });
 
       // Changes should persist after the change callback.
-      expect(Obj.getMeta(obj).tags).toEqual(['tag-1', 'tag-2']);
+      expect(tagUris(obj)).toEqual([tagRef('tag-1').uri, tagRef('tag-2').uri]);
       expect(Obj.getMeta(obj).keys).toEqual([{ source: 'external', id: '123' }]);
     });
 
@@ -218,13 +226,13 @@ describe('Obj.update enforcement', () => {
         obj.name = 'Name 1';
         obj.name = 'Name 2';
         obj.name = 'Name 3';
-        Obj.addTag(obj, 'tag-1');
-        Obj.addTag(obj, 'tag-2');
+        Obj.addTag(obj, tagRef('tag-1'));
+        Obj.addTag(obj, tagRef('tag-2'));
       });
 
       // All mutations should persist.
       expect(obj.name).toBe('Name 3');
-      expect(Obj.getMeta(obj).tags).toEqual(['tag-1', 'tag-2']);
+      expect(tagUris(obj)).toEqual([tagRef('tag-1').uri, tagRef('tag-2').uri]);
     });
   });
 
@@ -457,11 +465,11 @@ describe('Obj.update enforcement', () => {
 
       Relation.update(rel, (rel) => {
         const meta = Relation.getMeta(rel);
-        meta.tags = ['rel-tag'];
+        meta.tags = [tagRef('rel-tag')];
         meta.keys.push({ source: 'rel-source', id: 'rel-key' });
       });
 
-      expect(Relation.getMeta(rel).tags).toEqual(['rel-tag']);
+      expect(tagUris(rel)).toEqual([tagRef('rel-tag').uri]);
       expect(Relation.getMeta(rel).keys).toHaveLength(1);
     });
 
@@ -474,16 +482,16 @@ describe('Obj.update enforcement', () => {
       });
 
       Relation.update(rel, (rel) => {
-        Relation.addTag(rel, 'important');
+        Relation.addTag(rel, tagRef('important'));
       });
 
-      expect(Relation.getMeta(rel).tags).toContain('important');
+      expect(tagUris(rel)).toContain(tagRef('important').uri);
 
       Relation.update(rel, (rel) => {
-        Relation.removeTag(rel, 'important');
+        Relation.removeTag(rel, tagRef('important'));
       });
 
-      expect(Relation.getMeta(rel).tags).not.toContain('important');
+      expect(tagUris(rel)).not.toContain(tagRef('important').uri);
     });
   });
 

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

@@ -9,7 +9,7 @@ import { isNode } from '@dxos/util';
 
 import { TestSchema, updateCounter } from '../../../testing';
 import { createObject } from '../../Obj';
-import { ATTR_META } from '../types';
+import { ATTR_META } from '../types/meta';
 import { makeObject } from './make-object';
 import { objectData } from './proxy-types';
 import { change } from './reactive';

package/src/internal/common/proxy/json-serializer.ts

@@ -2,24 +2,22 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type ObjectMeta } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
-import { DXN } from '@dxos/keys';
-import { deepMapValues } from '@dxos/util';
+import { EID } from '@dxos/keys';
+import { deepMapValues, encodeUint8ArrayToJson } from '@dxos/util';
 
 import { Ref } from '../../Ref';
 import {
-  ATTR_META,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
-  ATTR_SELF_DXN,
+  ATTR_SELF_URI,
   ATTR_TYPE,
-  MetaId,
   RelationSourceDXNId,
   RelationTargetDXNId,
-  SelfDXNId,
+  SelfURIId,
   TypeId,
 } from '../types';
+import { ATTR_META, type EntityMeta, MetaId } from '../types/meta';
 
 /**
  * Attaches a toJSON method to the object for typed serialization.
@@ -48,26 +46,26 @@ export const typedJsonSerializer = function (this: any) {
   };
 
   if (this[TypeId]) {
-    result[ATTR_TYPE] = this[TypeId].toString();
+    result[ATTR_TYPE] = this[TypeId];
   }
 
   if (this[MetaId]) {
     result[ATTR_META] = serializeMeta(this[MetaId]);
   }
 
-  if (this[SelfDXNId]) {
-    result[ATTR_SELF_DXN] = this[SelfDXNId].toString();
+  if (this[SelfURIId]) {
+    result[ATTR_SELF_URI] = this[SelfURIId];
   }
 
   if (this[RelationSourceDXNId]) {
     const sourceDXN = this[RelationSourceDXNId];
-    invariant(sourceDXN instanceof DXN);
-    result[ATTR_RELATION_SOURCE] = sourceDXN.toString();
+    invariant(EID.isEID(sourceDXN));
+    result[ATTR_RELATION_SOURCE] = sourceDXN;
   }
   if (this[RelationTargetDXNId]) {
     const targetDXN = this[RelationTargetDXNId];
-    invariant(targetDXN instanceof DXN);
-    result[ATTR_RELATION_TARGET] = targetDXN.toString();
+    invariant(EID.isEID(targetDXN));
+    result[ATTR_RELATION_TARGET] = targetDXN;
   }
 
   Object.assign(result, serializeData(rest));
@@ -80,11 +78,23 @@ const serializeData = (data: unknown) => {
       // TODO(dmaretskyi): Should this be configurable?
       return value.noInline().encode();
     }
+    if (value instanceof Uint8Array) {
+      return encodeUint8ArrayToJson(value);
+    }
 
     return recurse(value);
   });
 };
 
-const serializeMeta = (meta: ObjectMeta) => {
-  return deepMapValues(meta, (value, recurse) => recurse(value));
+const serializeMeta = (meta: EntityMeta) => {
+  // Omit empty `tags`/`annotations` to keep serialized output minimal; `objectFromJSON` backfills
+  // the required defaults on read.
+  const { tags, annotations, ...rest } = meta;
+  const compact = {
+    ...rest,
+    ...(tags != null && tags.length > 0 ? { tags } : {}),
+    ...(annotations != null && Object.keys(annotations).length > 0 ? { annotations } : {}),
+  };
+  // Use `serializeData` so `meta.tags` `Ref<Tag>` values encode to the on-wire reference form.
+  return serializeData(compact);
 };

package/src/internal/common/proxy/make-object.ts

@@ -4,41 +4,56 @@
 
 import type * as Schema from 'effect/Schema';
 
-import { ObjectId } from '@dxos/keys';
+import { EntityId } from '@dxos/keys';
 
-import { getTypeAnnotation } from '../../Annotation';
-import { type AnyProperties, KindId, MetaId, type ObjectMeta, ObjectMetaSchema, ParentId } from '../types';
+import { getTypeAnnotation } from '../../Annotation/annotations';
+import { type AnyProperties, KindId, ParentId, SchemaKindId, StaticTypeSchemaSlot } from '../types';
+import { MetaId, type EntityMeta, EntityMetaSchema } from '../types/meta';
 import { defineHiddenProperty } from './define-hidden-property';
 import { attachTypedJsonSerializer } from './json-serializer';
 import { createProxy, getProxyTarget, isValidProxyTarget } from './proxy-utils';
-import { TypedReactiveHandler, prepareTypedTarget, setMetaOwner } from './typed-handler';
+import { TypeSource, TypedReactiveHandler, prepareTypedTarget, setMetaOwner } from './typed-handler';
 
 /**
  *
  */
 // TODO(burdon): Make internal
-export type MakeObjectProps<T extends AnyProperties> = Omit<T, 'id' | KindId>;
+// Omits the brand slots — those get stamped on the instance by the entity
+// handler (KindId via setKind, SchemaKindId derived in the proxy `get` trap
+// from kind + jsonSchema.entityKind, StaticTypeSchemaSlot lazily via the
+// proxy), not supplied by the caller.
+export type MakeObjectProps<T extends AnyProperties> = Omit<T, 'id' | KindId | SchemaKindId | StaticTypeSchemaSlot>;
 
 /**
  * Creates a reactive object from a plain Javascript object.
  * Requires a TS-effect schema.
+ *
+ * Callers that have a `Type.Type` entity (not a raw schema) must unwrap it
+ * themselves — `Obj.make` / `Relation.make` do this via `Type.getSchema(...)`
+ * and pass the entity through as `typeSource` so the instance carries a
+ * back-reference for `Obj.getType` and resolves the live source schema
+ * uniformly via the entity's `[StaticTypeSchemaSlot]`.
  */
 // 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.
-export const makeObject: {
-  <T extends AnyProperties>(
-    schema: Schema.Schema<T, any, never>,
-    obj: NoInfer<MakeObjectProps<T>>,
-    meta?: ObjectMeta,
-  ): T;
-} = <T extends AnyProperties>(schema: Schema.Schema<T, any>, obj: MakeObjectProps<T>, meta?: ObjectMeta): T => {
+export const makeObject = <T extends AnyProperties>(
+  schema: Schema.Schema<T, any, never>,
+  obj: NoInfer<MakeObjectProps<T>>,
+  meta?: Partial<EntityMeta>,
+  typeSource?: TypeSource,
+): T => {
   // Use Object.assign to copy symbol properties (like ParentId) that spread operator doesn't copy.
-  return createReactiveObject<T>(Object.assign({}, obj) as T, meta, schema);
+  return createReactiveObject<T>(Object.assign({}, obj) as T, meta, schema as Schema.Schema<T, any>, typeSource);
 };
 
-const createReactiveObject = <T extends AnyProperties>(obj: T, meta?: ObjectMeta, schema?: Schema.Schema<T>): T => {
+const createReactiveObject = <T extends AnyProperties>(
+  obj: T,
+  meta?: Partial<EntityMeta>,
+  schema?: Schema.Schema<T>,
+  typeSource?: TypeSource,
+): T => {
   if (!isValidProxyTarget(obj)) {
     throw new Error('Value cannot be made into a reactive object.');
   }
@@ -62,7 +77,7 @@ const createReactiveObject = <T extends AnyProperties>(obj: T, meta?: ObjectMeta
   if (parent !== undefined) {
     defineHiddenProperty(obj, ParentId, parent);
   }
-  prepareTypedTarget(obj, schema);
+  prepareTypedTarget(obj, schema, typeSource);
   attachTypedJsonSerializer(obj);
   const proxy = createProxy<T>(obj, TypedReactiveHandler.instance);
 
@@ -87,11 +102,11 @@ const createReactiveObject = <T extends AnyProperties>(obj: T, meta?: ObjectMeta
 const setIdOnTarget = (target: any) => {
   // invariant(!('id' in target), 'Object already has an `id` field, which is reserved.');
   if ('id' in target && target.id !== undefined && target.id !== null) {
-    if (!ObjectId.isValid(target.id)) {
+    if (!EntityId.isValid(target.id)) {
       throw new Error('Invalid object id format.');
     }
   } else {
-    target.id = ObjectId.random();
+    target.id = EntityId.random();
   }
 };
 
@@ -99,7 +114,15 @@ const setIdOnTarget = (target: any) => {
  * Set metadata on object.
  */
 // TODO(dmaretskyi): Move to echo-schema.
-const initMeta = <T>(obj: T, meta: ObjectMeta = { keys: [] }) => {
-  prepareTypedTarget(meta, ObjectMetaSchema);
-  defineHiddenProperty(obj, MetaId, createProxy(meta, TypedReactiveHandler.instance as any));
+const initMeta = <T>(obj: T, meta?: Partial<EntityMeta>) => {
+  // Backfill required fields so callers may pass a partial meta, or one whose `keys`/`tags`/
+  // `annotations` are explicitly `undefined` (coalesce, don't let a spread reintroduce undefined).
+  const fullMeta: EntityMeta = {
+    ...meta,
+    keys: meta?.keys ?? [],
+    tags: meta?.tags ?? [],
+    annotations: meta?.annotations ?? {},
+  };
+  prepareTypedTarget(fullMeta, EntityMetaSchema);
+  defineHiddenProperty(obj, MetaId, createProxy(fullMeta, TypedReactiveHandler.instance as any));
 };

package/src/internal/common/proxy/ownership.ts

@@ -221,12 +221,12 @@ export const getEchoRoot = (target: object, depth = 0): object => {
 
   // Root ECHO objects (those created with Obj.make or Relation.make) have KindId set.
   // They maintain their own change context identity even when nested inside another object.
-  // Nested helper objects like ObjectMeta don't have KindId and should follow their owner.
+  // Nested helper objects like EntityMeta don't have KindId and should follow their owner.
   if (KindId in target) {
     return target;
   }
 
-  // For non-root objects (nested records, ObjectMeta, etc.), follow the owner chain.
+  // For non-root objects (nested records, EntityMeta, etc.), follow the owner chain.
   const owner = getOwner(target);
   if (owner) {
     return getEchoRoot(owner, depth + 1);

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

@@ -6,34 +6,43 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
+import { invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
+
 import { createEchoSchema } from '../../../testing';
+import * as Type from '../../../Type';
 import { PropertyMeta, getPropertyMetaAnnotation, getTypeAnnotation } from '../../Annotation';
 import { EchoObjectSchema } from '../../Entity';
 
-// TODO(dmaretskyi): Comment.
-const EmptySchemaType = Schema.Struct({}).pipe(
-  EchoObjectSchema({
-    typename: 'com.example.type.empty',
-    version: '0.1.0',
-  }),
-);
+// Test-local: introspect a Type.Type entity's properties via its rebuilt Effect
+// Schema, filter the implicit `id` field, and unwrap `T | undefined` optionality.
+const getProperties = (type: Type.Type): SchemaAST.PropertySignature[] => {
+  const ast = Type.getSchema(type).ast;
+  invariant(SchemaAST.isTypeLiteral(ast));
+  return [...ast.propertySignatures]
+    .filter((p) => p.name !== 'id')
+    .map((p) => {
+      if (!SchemaAST.isUnion(p.type)) {
+        return p;
+      }
+      const nonUndefined = p.type.types.find((t) => !SchemaAST.isUndefinedKeyword(t))!;
+      return { ...p, type: nonUndefined } as SchemaAST.PropertySignature;
+    });
+};
+
+const EmptySchemaType = Schema.Struct({}).pipe(EchoObjectSchema(DXN.make('com.example.type.empty', '0.1.0')));
 
-interface EmptySchemaType extends Schema.Schema.Type<typeof EmptySchemaType> {}
+type EmptySchemaType = Type.InstanceType<typeof EmptySchemaType>;
 
 describe('dynamic schema', () => {
   test('getProperties filters out id and unwraps optionality', async () => {
     const TestSchema = Schema.Struct({
       field1: Schema.String,
       field2: Schema.Boolean,
-    }).pipe(
-      EchoObjectSchema({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(EchoObjectSchema(DXN.make('com.example.type.test', '0.1.0')));
 
-    const registered = createEchoSchema(TestSchema);
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
+    const registered = createEchoSchema(Type.getSchema(TestSchema));
+    expect(getProperties(registered).map((p) => [p.name, p.type])).to.deep.eq([
       ['field1', SchemaAST.stringKeyword],
       ['field2', SchemaAST.booleanKeyword],
     ]);
@@ -42,28 +51,23 @@ describe('dynamic schema', () => {
   test('addColumns', async () => {
     const TestSchema = Schema.Struct({
       field1: Schema.String,
-    }).pipe(
-      EchoObjectSchema({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(EchoObjectSchema(DXN.make('com.example.type.test', '0.1.0')));
 
-    const registered = createEchoSchema(TestSchema);
-    registered.addFields({ field2: Schema.Boolean });
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
+    const registered = createEchoSchema(Type.getSchema(TestSchema));
+    Type.addFields(registered, { field2: Schema.Boolean });
+    expect(getProperties(registered).map((p) => [p.name, p.type])).to.deep.eq([
       ['field1', SchemaAST.stringKeyword],
       ['field2', SchemaAST.booleanKeyword],
     ]);
   });
 
   test('updateColumns preserves order of existing and appends new fields', async () => {
-    const registered = createEchoSchema(EmptySchemaType);
-    registered.addFields({ field1: Schema.String });
-    registered.addFields({ field2: Schema.Boolean });
-    registered.addFields({ field3: Schema.Number });
-    registered.updateFields({ field4: Schema.Boolean, field2: Schema.String });
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
+    const registered = createEchoSchema(Type.getSchema(EmptySchemaType));
+    Type.addFields(registered, { field1: Schema.String });
+    Type.addFields(registered, { field2: Schema.Boolean });
+    Type.addFields(registered, { field3: Schema.Number });
+    Type.updateFields(registered, { field4: Schema.Boolean, field2: Schema.String });
+    expect(getProperties(registered).map((p) => [p.name, p.type])).to.deep.eq([
       ['field1', SchemaAST.stringKeyword],
       ['field2', SchemaAST.stringKeyword],
       ['field3', SchemaAST.numberKeyword],
@@ -72,12 +76,12 @@ describe('dynamic schema', () => {
   });
 
   test('removeColumns', async () => {
-    const registered = createEchoSchema(EmptySchemaType);
-    registered.addFields({ field1: Schema.String });
-    registered.addFields({ field2: Schema.Boolean });
-    registered.addFields({ field3: Schema.Number });
-    registered.removeFields(['field2']);
-    expect(registered.getProperties().map((p) => [p.name, p.type])).to.deep.eq([
+    const registered = createEchoSchema(Type.getSchema(EmptySchemaType));
+    Type.addFields(registered, { field1: Schema.String });
+    Type.addFields(registered, { field2: Schema.Boolean });
+    Type.addFields(registered, { field3: Schema.Number });
+    Type.removeFields(registered, ['field2']);
+    expect(getProperties(registered).map((p) => [p.name, p.type])).to.deep.eq([
       ['field1', SchemaAST.stringKeyword],
       ['field3', SchemaAST.numberKeyword],
     ]);
@@ -86,60 +90,18 @@ describe('dynamic schema', () => {
   test('schema manipulations preserve annotations', async () => {
     const metaNamespace = 'dxos.test';
     const metaInfo = { maxLength: 10 };
-    const registered = createEchoSchema(EmptySchemaType);
-    registered.addFields({
+    const registered = createEchoSchema(Type.getSchema(EmptySchemaType));
+    Type.addFields(registered, {
       field1: Schema.String.pipe(PropertyMeta(metaNamespace, metaInfo)),
       field2: Schema.String,
     });
-    registered.addFields({ field3: Schema.String });
-    registered.updateFields({ field3: Schema.Boolean });
-    registered.removeFields(['field2']);
-    expect(getTypeAnnotation(registered)).to.deep.contain({
+    Type.addFields(registered, { field3: Schema.String });
+    Type.updateFields(registered, { field3: Schema.Boolean });
+    Type.removeFields(registered, ['field2']);
+    expect(getTypeAnnotation(Type.getSchema(registered))).to.deep.contain({
       typename: 'com.example.type.empty',
       version: '0.1.0',
     });
-    expect(getPropertyMetaAnnotation(registered.getProperties()[0], metaNamespace)).to.deep.eq(metaInfo);
-  });
-
-  test('updates typename', async ({ expect }) => {
-    // Create schema with some fields and annotations.
-    const registered = createEchoSchema(EmptySchemaType);
-    const originalVersion = registered.persistentSchema.version;
-    registered.addFields({
-      name: Schema.String.pipe(PropertyMeta('test', { maxLength: 10 })),
-      age: Schema.Number,
-    });
-
-    // First update.
-    const newTypename1 = 'com.example.type.individual';
-    registered.updateTypename(newTypename1);
-
-    // Basic typename update checks.
-    expect(registered.typename).toBe(newTypename1);
-    expect(registered.jsonSchema.$id).toBe(`dxn:type:${newTypename1}`);
-    expect(registered.jsonSchema.typename).toBe(newTypename1);
-
-    // Version preservation check.
-    expect(registered.persistentSchema.version).toBe(originalVersion);
-
-    // Field preservation check.
-    const properties = registered.getProperties();
-    expect(properties).toHaveLength(2);
-    expect(properties[0].name).toBe('name');
-
-    // Annotation preservation check.
-    const nameMeta = getPropertyMetaAnnotation(properties[0], 'test');
-    expect(nameMeta).toEqual({ maxLength: 10 });
-
-    // Second update to ensure multiple updates work.
-    const newTypename2 = 'com.example.type.person';
-    registered.updateTypename(newTypename2);
-    expect(registered.typename).toBe(newTypename2);
-    expect(registered.jsonSchema.$id).toBe(`dxn:type:${newTypename2}`);
-    expect(registered.jsonSchema.typename).toBe(newTypename2);
-    expect(getTypeAnnotation(registered)).to.deep.contain({
-      typename: 'com.example.type.person',
-      version: '0.1.0',
-    });
+    expect(getPropertyMetaAnnotation(getProperties(registered)[0], metaNamespace)).to.deep.eq(metaInfo);
   });
 });

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

@@ -5,11 +5,14 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
+import { DXN } from '@dxos/keys';
+
+import * as Obj from '../../../Obj';
 import { TestSchema } from '../../../testing';
 import { EchoObjectSchema } from '../../Entity';
 import { setValue } from '../../Obj';
 import { Ref } from '../../Ref';
-import { foreignKey, getMeta } from '../types';
+import { foreignKey, getMeta } from '../types/meta';
 import { makeObject } from './make-object';
 import { change, subscribe } from './reactive';
 
@@ -39,15 +42,13 @@ describe('complex schema validations', () => {
 
   test('references', () => {
     const Foo = Schema.Struct({ field: Schema.String }).pipe(
-      EchoObjectSchema({ typename: 'com.example.type.foo', version: '0.1.0' }),
-    );
-    const Bar = Schema.Struct({ fooRef: Ref(Foo) }).pipe(
-      EchoObjectSchema({ typename: 'com.example.type.bar', version: '0.1.0' }),
+      EchoObjectSchema(DXN.make('com.example.type.foo', '0.1.0')),
     );
+    const Bar = Schema.Struct({ fooRef: Ref(Foo) }).pipe(EchoObjectSchema(DXN.make('com.example.type.bar', '0.1.0')));
     const field = 'hello';
-    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(() => Obj.make(Bar, { fooRef: { id: '1', field } as any })).to.throw();
+    expect(() => Obj.make(Bar, { fooRef: undefined as any })).to.throw(); // Unresolved reference.
+    const bar = Obj.make(Bar, { fooRef: Ref.make(Obj.make(Foo, { field })) });
     expect(bar.fooRef.target?.field).to.eq(field);
   });
 
@@ -79,7 +80,7 @@ describe('complex schema validations', () => {
   // Untyped reactive objects are no longer supported - use Atoms for untyped reactive state.
 
   test('creating an object with data from another object', () => {
-    const contact = makeObject(TestSchema.Person, {
+    const contact = Obj.make(TestSchema.Person, {
       name: 'Robert Smith',
       email: 'robert@example.com',
     });
@@ -94,9 +95,9 @@ describe('complex schema validations', () => {
 
   test('subscribe', () => {
     const TestSchema = Schema.Struct({ field: Schema.String }).pipe(
-      EchoObjectSchema({ typename: 'Test', version: '0.1.0' }),
+      EchoObjectSchema(DXN.make('com.test.type.test', '0.1.0')),
     );
-    const object = makeObject(TestSchema, { field: 'value' });
+    const object = Obj.make(TestSchema, { field: 'value' });
     let called = 0;
     const unsubscribe = subscribe(object as any, () => {
       called++;