@dxos/echo 0.8.4-main.40e3dcdf1b → 0.8.4-main.43cb759274

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,42 +4,56 @@
 
 import type * as Schema from 'effect/Schema';
 
-import { ObjectId } from '@dxos/keys';
-
-import { getTypeAnnotation } from '../../Annotation';
-import { type AnyProperties, KindId, MetaId, type ObjectMeta, ObjectMetaSchema, ParentId } from '../types';
+import { EntityId } from '@dxos/keys';
 
+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.');
   }
@@ -63,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);
 
@@ -88,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();
   }
 };
 
@@ -100,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

@@ -5,7 +5,6 @@
 import { invariant } from '@dxos/invariant';
 
 import { KindId } from '../types';
-
 import { queueOwnerNotification } from './change-context';
 import { defineHiddenProperty } from './define-hidden-property';
 import { getProxyTarget, isProxy, isValidProxyTarget } from './proxy-utils';
@@ -222,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/reactive-array.ts

@@ -34,7 +34,7 @@ const checkArrayMutationAllowed = (arr: any, method: string): void => {
 
 /**
  * Extends the native array to make sure that arrays methods are correctly reactive.
- * Enforces that mutations only happen within Obj.change() context.
+ * Enforces that mutations only happen within Obj.update() context.
  */
 export class ReactiveArray<T> extends Array<T> {
   static override get [Symbol.species]() {

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

@@ -0,0 +1,54 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import * as Obj from '../../../Obj';
+import { TestSchema } from '../../../testing';
+
+describe('Obj.subscribe', () => {
+  test('subscribes and fires for reactive proxies', () => {
+    const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+    let calls = 0;
+    const unsubscribe = Obj.subscribe(obj, () => {
+      calls++;
+    });
+
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
+    });
+    expect(calls).toBeGreaterThan(0);
+
+    unsubscribe();
+    const seen = calls;
+    Obj.update(obj, (obj) => {
+      obj.name = 'After unsubscribe';
+    });
+    expect(calls).toBe(seen);
+  });
+
+  // Regression: queue-stored typed objects (e.g. AiContext.Binding) and other Obj-shaped values
+  // satisfy `Obj.isObject` (KindId is set) but are not wrapped in a reactive Proxy. Earlier
+  // versions invariant'd inside `getProxyTarget` when an atom body did `Obj.subscribe(obj)` on
+  // such an input. The contract is "no-op for non-reactive inputs"; verify the function
+  // returns gracefully instead of throwing.
+  test('returns a no-op unsubscribe for non-proxy inputs', () => {
+    const queueShaped: any = {
+      id: '01KQ5NKXJWSKMRPVTVG2GHV8V3',
+      blueprints: { added: [], removed: [] },
+      objects: { added: [], removed: [] },
+    };
+    const unsubscribe = Obj.subscribe(queueShaped, () => {});
+    expect(typeof unsubscribe).toBe('function');
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  test('returns a no-op unsubscribe for primitives, null, and undefined', () => {
+    for (const value of [null, undefined, 42, 'string', true]) {
+      const unsubscribe = Obj.subscribe(value as any, () => {});
+      expect(typeof unsubscribe).toBe('function');
+      expect(() => unsubscribe()).not.toThrow();
+    }
+  });
+});

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

@@ -3,8 +3,7 @@
 //
 
 import { type RefTypeId } from '../../Ref/ref';
-
-import { getProxyTarget } from './proxy-utils';
+import { getProxyTarget, isProxy } from './proxy-utils';
 import { ChangeId, EventId } from './symbols';
 
 /**
@@ -15,6 +14,15 @@ import { ChangeId, EventId } from './symbols';
  */
 // TODO(wittjosiah): Consider throwing if obj doesn't have EventId instead of returning no-op.
 export const subscribe = (obj: unknown, callback: () => void): (() => void) => {
+  // Guard against non-reactive inputs (queue-stored typed objects, snapshots, plain shapes
+  // with branded symbols) before `getProxyTarget`'s `ProxyHandlerSlot` invariant kicks in.
+  // `Obj.isObject` (KindId-based) is satisfied by these inputs, so callers like
+  // `Atom.family((obj) => Atom.make((get) => Obj.subscribe(obj, ...)))` legitimately reach
+  // here with a non-proxy. Falling back to a no-op preserves the documented contract that
+  // values without subscription support get a no-op unsubscribe.
+  if (!isProxy(obj)) {
+    return () => {};
+  }
   const target = getProxyTarget(obj as any);
   if (target && EventId in target) {
     return (target as any)[EventId].on(callback);
@@ -24,7 +32,7 @@ export const subscribe = (obj: unknown, callback: () => void): (() => void) => {
 
 /**
  * Deeply removes readonly modifiers from all properties of T.
- * Inside Obj.change, all properties are fully mutable regardless of schema definition.
+ * Inside Obj.update, all properties are fully mutable regardless of schema definition.
  * Ref types are preserved as-is since they are value-like objects that are replaced, not mutated.
  * Primitive types (including branded primitives) are preserved as-is.
  */

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,12 +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';
 
@@ -40,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);
   });
 
@@ -80,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',
     });
@@ -95,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++;