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

package/src/internal/{object → Obj}/json-serializer.ts

@@ -7,26 +7,13 @@ import * as Schema from 'effect/Schema';
 import { raise } from '@dxos/debug';
 import { type EncodedReference, ObjectStructure, isEncodedReference } from '@dxos/echo-protocol';
 import { assertArgument, invariant } from '@dxos/invariant';
-import { DXN, ObjectId } from '@dxos/keys';
-import { assumeType, deepMapValues, visitValues } from '@dxos/util';
+import { EchoURI, ObjectId, URI } from '@dxos/keys';
+import { assumeType, decodeUint8ArrayFromJson, deepMapValues, isEncodedUint8Array, visitValues } from '@dxos/util';
 
+import type * as Database from '../../Database';
 import type * as Obj from '../../Obj';
-import { getTypeDXN, setTypename } from '../annotations';
-import {
-  ATTR_DELETED,
-  ATTR_RELATION_SOURCE,
-  ATTR_RELATION_TARGET,
-  ATTR_SELF_DXN,
-  type ObjectJSON,
-  RelationSourceDXNId,
-  RelationSourceId,
-  RelationTargetDXNId,
-  RelationTargetId,
-  SelfDXNId,
-  assertObjectModel,
-} from '../entities';
-import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../proxy';
-import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../ref';
+import { getTypeAnnotation, getTypeURI, setTypename } from '../Annotation';
+import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../common/proxy';
 import {
   ATTR_META,
   ATTR_PARENT,
@@ -38,7 +25,24 @@ import {
   ObjectMetaSchema,
   ParentId,
   setSchema,
-} from '../types';
+  setType,
+} from '../common/types';
+import {
+  ATTR_DELETED,
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
+  ObjectDatabaseId,
+  type ObjectJSON,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SelfURIId,
+  assertObjectModel,
+} from '../Entity';
+import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../Ref';
 
 // Re-export for backward compatibility.
 export { attachTypedJsonSerializer };
@@ -60,7 +64,7 @@ type SerializedObject<T extends { id: string }> = {
  * Converts object to it's JSON representation.
  */
 export const objectToJSON = <T extends AnyEntity>(obj: T): SerializedObject<T> => {
-  const typename = getTypeDXN(obj)?.toString();
+  const typename = getTypeURI(obj);
   invariant(typename && typeof typename === 'string');
   return typedJsonSerializer.call(obj);
 };
@@ -70,28 +74,39 @@ export const objectToJSON = <T extends AnyEntity>(obj: T): SerializedObject<T> =
  * 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.
+ *
+ * @param jsonData - JSON representation of the object.
+ * @param options.refResolver - Resolver for references.
+ * @param options.uri - Override object URI.
+ * @param options.database - Database to associate with the object.
  */
 export const objectFromJSON = async (
   jsonData: unknown,
-  { refResolver, dxn }: { refResolver?: RefResolver; dxn?: DXN } = {},
+  {
+    refResolver,
+    uri,
+    database,
+    parent,
+  }: { refResolver?: RefResolver; uri?: URI.URI; database?: Database.Database; parent?: Obj.Unknown } = {},
 ): Promise<AnyEntity> => {
   assumeType<ObjectJSON>(jsonData);
   assertArgument(typeof jsonData === 'object' && jsonData !== null, 'jsonData', 'expect object');
   assertArgument(typeof jsonData[ATTR_TYPE] === 'string', 'jsonData[ATTR_TYPE]', 'expected object to have a type');
   assertArgument(typeof jsonData.id === 'string', 'jsonData.id', 'expected object to have an id');
 
-  const type = DXN.parse(jsonData[ATTR_TYPE]);
+  const type = URI.make(jsonData[ATTR_TYPE]);
   const schema = await refResolver?.resolveSchema(type);
   invariant(schema === undefined || Schema.isSchema(schema));
+  const decodedInput = restoreUint8Arrays(stripInternalJsonKeys(jsonData));
 
   let obj: any;
   if (schema != null) {
-    obj = await schema.pipe(Schema.decodeUnknownPromise)(jsonData);
+    obj = await schema.pipe(Schema.decodeUnknownPromise)(decodedInput);
     if (refResolver) {
       setRefResolverOnData(obj, refResolver);
     }
   } else {
-    obj = decodeGeneric(jsonData, { refResolver });
+    obj = decodeGeneric(decodedInput, { refResolver });
   }
 
   invariant(ObjectId.isValid(obj.id), 'Invalid object id');
@@ -99,12 +114,21 @@ export const objectFromJSON = async (
   if (schema) {
     setSchema(obj, schema);
   }
+  // Resolve and stamp the source type entity, if the resolver provides one.
+  // Lets `Obj.getType` / `Entity.getType` return a stable entity for objects
+  // loaded via `Obj.fromJSON` (serializer / queue paths).
+  if (refResolver?.resolveType) {
+    const typeEntity = await refResolver.resolveType(type);
+    if (typeEntity != null) {
+      setType(obj, typeEntity);
+    }
+  }
 
   const isRelation =
     typeof jsonData[ATTR_RELATION_SOURCE] === 'string' || typeof jsonData[ATTR_RELATION_TARGET] === 'string';
   if (isRelation) {
-    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')));
+    const sourceDxn = jsonData[ATTR_RELATION_SOURCE] ?? raise(new TypeError('Missing relation source'));
+    const targetDxn = jsonData[ATTR_RELATION_TARGET] ?? raise(new TypeError('Missing relation target'));
 
     const source = (await refResolver?.resolve(sourceDxn)) as AnyEntity | undefined;
     const target = (await refResolver?.resolve(targetDxn)) as AnyEntity | undefined;
@@ -115,7 +139,13 @@ export const objectFromJSON = async (
     defineHiddenProperty(obj, RelationSourceId, source);
     defineHiddenProperty(obj, RelationTargetId, target);
   } else {
-    defineHiddenProperty(obj, KindId, EntityKind.Object);
+    // Honour the schema's TypeAnnotation kind — persisted `Type.Type` entities
+    // (e.g. dynamic schemas loaded from a snapshot import) must brand as
+    // `KindId = Type`, not Object, otherwise `Filter.type(Type.Type)` /
+    // `Type.isType` skip them and the schema registry never picks them up.
+    // Mirrors the kind resolution in `createObject` (the in-memory path).
+    const annotationKind = schema != null ? getTypeAnnotation(schema)?.kind : undefined;
+    defineHiddenProperty(obj, KindId, annotationKind === EntityKind.Type ? EntityKind.Type : EntityKind.Object);
   }
 
   if (typeof jsonData[ATTR_META] === 'object') {
@@ -129,43 +159,72 @@ export const objectFromJSON = async (
   }
 
   if (jsonData[ATTR_PARENT]) {
-    const parentDxn = DXN.parse(jsonData[ATTR_PARENT]);
-    const parent = (await refResolver?.resolve(parentDxn)) as Obj.Unknown | undefined;
+    const parentDxn = jsonData[ATTR_PARENT];
+    const resolvedParent = (await refResolver?.resolve(parentDxn)) as Obj.Unknown | undefined;
+    defineHiddenProperty(obj, ParentId, resolvedParent);
+  } else if (parent) {
     defineHiddenProperty(obj, ParentId, parent);
   }
 
-  if (dxn) {
-    defineHiddenProperty(obj, SelfDXNId, dxn);
+  if (uri) {
+    defineHiddenProperty(obj, SelfURIId, uri);
+  }
+
+  if (database) {
+    defineHiddenProperty(obj, ObjectDatabaseId, database);
   }
 
   assertObjectModel(obj);
   invariant((obj as any)[ATTR_TYPE] === 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_SELF_URI] === undefined, 'Invalid object model');
+  invariant((obj as any)[ATTR_SELF_URI_LEGACY] === 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');
   return obj;
 };
 
 const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }) => {
+  const props = stripInternalJsonKeys(jsonData);
+
+  return deepMapValues(props, (value, visitor) => {
+    if (isEncodedReference(value)) {
+      return refFromEncodedReference(value, options.refResolver);
+    }
+    if (isEncodedUint8Array(value)) {
+      return decodeUint8ArrayFromJson(value);
+    }
+
+    return visitor(value);
+  });
+};
+
+/**
+ * Recursively replaces encoded `Uint8Array` JSON markers with actual `Uint8Array` instances.
+ * Runs before schema decoding so `Schema.Uint8ArrayFromSelf` sees real bytes.
+ */
+const restoreUint8Arrays = (data: unknown): any =>
+  deepMapValues(data, (value, recurse) => {
+    if (isEncodedUint8Array(value)) {
+      return decodeUint8ArrayFromJson(value);
+    }
+    return recurse(value);
+  });
+
+const stripInternalJsonKeys = (jsonData: unknown) => {
   const {
     [ATTR_TYPE]: _type,
     [ATTR_META]: _meta,
     [ATTR_DELETED]: _deleted,
-    [ATTR_SELF_DXN]: _selfDxn,
+    [ATTR_SELF_URI]: _selfUri,
+    [ATTR_SELF_URI_LEGACY]: _legacySelfUri,
     [ATTR_RELATION_SOURCE]: _relationSource,
     [ATTR_RELATION_TARGET]: _relationTarget,
     ...props
   } = jsonData as any;
 
-  return deepMapValues(props, (value, visitor) => {
-    if (isEncodedReference(value)) {
-      return refFromEncodedReference(value, options.refResolver);
-    }
-
-    return visitor(value);
-  });
+  return props;
 };
 
 export const setRefResolverOnData = (obj: AnyEntity, refResolver: RefResolver) => {
@@ -184,14 +243,18 @@ export const setRefResolverOnData = (obj: AnyEntity, refResolver: RefResolver) =
  * Convert ObjectStructure to JSON data for indexing.
  * Different from {@link objectToJSON} as it takes the internal {@link ObjectStructure} representation directly
  */
-export const objectStructureToJson = (objectId: string, structure: ObjectStructure): Obj.JSON => {
+export const objectStructureToJson = (objectId: ObjectId, structure: ObjectStructure): Obj.JSON => {
+  const typeRef = ObjectStructure.getTypeReference(structure)?.['/'];
+  const parent = ObjectStructure.getParent(structure)?.['/'];
+  const source = ObjectStructure.getRelationSource(structure)?.['/'];
+  const target = ObjectStructure.getRelationTarget(structure)?.['/'];
   return {
     ...structure.data,
     id: objectId,
-    [ATTR_TYPE]: (ObjectStructure.getTypeReference(structure)?.['/'] ?? '') as DXN.String,
+    [ATTR_TYPE]: typeRef ? URI.make(typeRef) : undefined,
     [ATTR_DELETED]: ObjectStructure.isDeleted(structure),
-    [ATTR_PARENT]: ObjectStructure.getParent(structure)?.['/'] as DXN.String | undefined,
-    [ATTR_RELATION_SOURCE]: ObjectStructure.getRelationSource(structure)?.['/'] as DXN.String | undefined,
-    [ATTR_RELATION_TARGET]: ObjectStructure.getRelationTarget(structure)?.['/'] as DXN.String | undefined,
+    [ATTR_PARENT]: parent !== undefined ? EchoURI.tryParse(parent) : undefined,
+    [ATTR_RELATION_SOURCE]: source !== undefined ? EchoURI.tryParse(source) : undefined,
+    [ATTR_RELATION_TARGET]: target !== undefined ? EchoURI.tryParse(target) : undefined,
   };
 };

package/src/internal/{object → Obj}/schema-validator.ts

@@ -3,4 +3,4 @@
 //
 
 // Re-export from proxy for backward compatibility.
-export { SchemaValidator, checkIdNotPresentOnSchema } from '../proxy';
+export { SchemaValidator, checkIdNotPresentOnSchema } from '../common/proxy';

package/src/internal/{object → Obj}/set-value.test.ts

@@ -5,6 +5,8 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
+import { DXN } from '@dxos/keys';
+
 import * as Obj from '../../Obj';
 import { TestSchema } from '../../testing';
 import * as Type from '../../Type';
@@ -17,7 +19,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+    Obj.update(person, (person) => Obj.setValue(person, ['address', 'city'], 'NYC'));
 
     expect(person.address).toBeDefined();
     expect(person.address?.city).toBe('NYC');
@@ -30,7 +32,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['fields', 0, 'label'], 'Phone'));
+    Obj.update(person, (person) => Obj.setValue(person, ['fields', 0, 'label'], 'Phone'));
 
     expect(Array.isArray(person.fields)).toBe(true);
     expect(person.fields?.[0].label).toBe('Phone');
@@ -45,7 +47,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'coordinates', 'lat'], 40.7128));
+    Obj.update(person, (person) => Obj.setValue(person, ['address', 'coordinates', 'lat'], 40.7128));
 
     expect(person.address).toBeDefined();
     expect(person.address?.coordinates).toBeDefined();
@@ -60,19 +62,14 @@ describe('Obj.setValue', () => {
     const Container = Schema.Struct({
       name: Schema.String,
       items: Schema.optional(Schema.Array(Item)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Container',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
 
     const container = Obj.make(Container, { name: 'box' });
 
-    Obj.change(container, (c) => {
-      Obj.setValue(c, ['items', 0, 'value'], 10);
-      Obj.setValue(c, ['items', 1, 'value'], 20);
-      Obj.setValue(c, ['items', 2, 'value'], 30);
+    Obj.update(container, (container) => {
+      Obj.setValue(container, ['items', 0, 'value'], 10);
+      Obj.setValue(container, ['items', 1, 'value'], 20);
+      Obj.setValue(container, ['items', 2, 'value'], 30);
     });
 
     expect(container.items).toHaveLength(3);
@@ -88,7 +85,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['age'], 25));
+    Obj.update(person, (person) => Obj.setValue(person, ['age'], 25));
 
     expect(person.age).toBe(25);
   });
@@ -100,7 +97,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+    Obj.update(person, (person) => Obj.setValue(person, ['address', 'city'], 'NYC'));
 
     expect(person.address).toBeDefined();
     expect(person.address?.city).toBe('NYC');
@@ -114,8 +111,8 @@ describe('Obj.setValue', () => {
     });
 
     let result: any;
-    Obj.change(person, (p) => {
-      result = Obj.setValue(p, ['age'], 30);
+    Obj.update(person, (person) => {
+      result = Obj.setValue(person, ['age'], 30);
     });
 
     expect(result).toBe(30);
@@ -129,7 +126,7 @@ describe('Obj.setValue', () => {
       age: 25,
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['age'], 30));
+    Obj.update(person, (person) => Obj.setValue(person, ['age'], 30));
 
     expect(person.age).toBe(30);
   });
@@ -142,7 +139,7 @@ describe('Obj.setValue', () => {
       address: { city: 'Boston', state: 'MA', coordinates: {} },
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+    Obj.update(person, (person) => Obj.setValue(person, ['address', 'city'], 'NYC'));
 
     expect(person.address?.city).toBe('NYC');
     expect(person.address?.state).toBe('MA');
@@ -151,20 +148,15 @@ describe('Obj.setValue', () => {
   test('handles two-dimensional arrays', ({ expect }) => {
     const Matrix = Schema.Struct({
       values: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Matrix',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.matrix', '0.1.0')));
 
     const matrix = Obj.make(Matrix, {});
 
-    Obj.change(matrix, (m) => {
-      Obj.setValue(m, ['values', 0, 0], 1);
-      Obj.setValue(m, ['values', 0, 1], 2);
-      Obj.setValue(m, ['values', 1, 0], 3);
-      Obj.setValue(m, ['values', 1, 1], 4);
+    Obj.update(matrix, (matrix) => {
+      Obj.setValue(matrix, ['values', 0, 0], 1);
+      Obj.setValue(matrix, ['values', 0, 1], 2);
+      Obj.setValue(matrix, ['values', 1, 0], 3);
+      Obj.setValue(matrix, ['values', 1, 1], 4);
     });
 
     expect(matrix.values?.[0][0]).toBe(1);
@@ -180,8 +172,8 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => {
-      expect(() => Obj.setValue(p, [], 'value')).toThrow('Path must not be empty');
+    Obj.update(person, (person) => {
+      expect(() => Obj.setValue(person, [], 'value')).toThrow('Path must not be empty');
     });
   });
 
@@ -192,7 +184,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['age'], 30));
+    Obj.update(person, (person) => Obj.setValue(person, ['age'], 30));
 
     expect(person.age).toBe(30);
   });
@@ -205,17 +197,12 @@ describe('Obj.setValue', () => {
     const Container = Schema.Struct({
       name: Schema.String,
       items: Schema.optional(Schema.Array(Item)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Container',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
 
     const container = Obj.make(Container, { name: 'box' });
 
     // Using string '0' for array index.
-    Obj.change(container, (c) => Obj.setValue(c, ['items', '0', 'value'], 42));
+    Obj.update(container, (container) => Obj.setValue(container, ['items', '0', 'value'], 42));
 
     expect(container.items?.[0].value).toBe(42);
   });
@@ -232,18 +219,13 @@ describe('Obj.setValue', () => {
     const TodoList = Schema.Struct({
       name: Schema.String,
       tasks: Schema.optional(Schema.Array(Task)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/TodoList',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.todoList', '0.1.0')));
 
     const todoList = Obj.make(TodoList, { name: 'My Tasks' });
 
     // This should work: setting a nested property on an array element.
     // The required 'id' field should be initialized with a default value.
-    Obj.change(todoList, (t) => Obj.setValue(t, ['tasks', 0, 'title'], 'Buy groceries'));
+    Obj.update(todoList, (todoList) => Obj.setValue(todoList, ['tasks', 0, 'title'], 'Buy groceries'));
 
     expect(todoList.tasks?.[0].id).toBe(''); // Default value for required String
     expect(todoList.tasks?.[0].title).toBe('Buy groceries');
@@ -261,16 +243,11 @@ describe('Obj.setValue', () => {
     const Container = Schema.Struct({
       name: Schema.String,
       items: Schema.optional(Schema.Array(Item)),
-    }).pipe(
-      Type.object({
-        typename: 'test.com/Container',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
 
     const container = Obj.make(Container, { name: 'box' });
 
-    Obj.change(container, (c) => Obj.setValue(c, ['items', 0, 'label'], 'First Item'));
+    Obj.update(container, (container) => Obj.setValue(container, ['items', 0, 'label'], 'First Item'));
 
     // All required primitive fields should have default values.
     expect(container.items?.[0].id).toBe('');

package/src/internal/{object → Obj}/set-value.ts

@@ -16,12 +16,12 @@ import {
 } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 
-import { type Mutable } from '../proxy';
-import { getSchema } from '../types';
+import { type Mutable } from '../common/proxy';
+import { getSchema } from '../common/types';
 
 /**
  * Set a deeply nested property on an object.
- * Must be called within an Obj.change or Relation.change callback.
+ * Must be called within an Obj.update or Relation.update callback.
  */
 export const setValue = (obj: Mutable<any>, path: readonly (string | number)[], value: any): void => {
   invariant(path.length > 0, 'Path must not be empty');

package/src/internal/{object → Obj}/snapshot.ts

@@ -2,13 +2,25 @@
 // Copyright 2024 DXOS.org
 //
 
+import { assertArgument } from '@dxos/invariant';
 import { deepMapValues } from '@dxos/util';
 
-import { ObjectDatabaseId } from '../entities/model';
-import { RelationSourceDXNId, RelationSourceId, RelationTargetDXNId, RelationTargetId } from '../entities/relation';
-import { KindId, SnapshotKindId } from '../types/entity';
-import { MetaId } from '../types/meta';
-import { SchemaId, TypeId } from '../types/typename';
+import {
+  KindId,
+  MetaId,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  ParentId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SchemaId,
+  SelfURIId,
+  SnapshotKindId,
+  TypeEntityId,
+  TypeId,
+} from '../common/types';
 
 /**
  * Copy a Symbol-keyed property from source to target if it has a defined value.
@@ -45,6 +57,8 @@ const copySymbolProperty = (
  * The snapshot is branded with SnapshotKindId (not KindId).
  */
 export const getSnapshot = <T extends object>(obj: T): T => {
+  assertArgument(typeof obj === 'object' && obj !== null && KindId in obj, 'obj', 'must be an entity');
+
   const snapshot = deepMapValues(obj, (value, recurse) => {
     // Do not recurse on references (but do recurse on arrays).
     if (
@@ -66,28 +80,32 @@ export const getSnapshot = <T extends object>(obj: T): T => {
 
   // Preserve Symbol-keyed properties that are important for type introspection.
   // These are not copied by deepMapValues since Object.keys() doesn't include symbols.
-  if (obj != null && typeof obj === 'object') {
-    const source = obj as any;
+  const source = obj as any;
 
-    // Type introspection symbols.
-    copySymbolProperty(source, snapshot, TypeId);
-    copySymbolProperty(source, snapshot, SchemaId);
+  // Type introspection symbols.
+  copySymbolProperty(source, snapshot, TypeId);
+  copySymbolProperty(source, snapshot, SchemaId);
+  copySymbolProperty(source, snapshot, TypeEntityId);
+  copySymbolProperty(source, snapshot, SelfURIId);
 
-    // Database reference (required for Obj.getDatabase to work on snapshots).
-    copySymbolProperty(source, snapshot, ObjectDatabaseId);
+  // Database reference (required for Obj.getDatabase to work on snapshots).
+  copySymbolProperty(source, snapshot, ObjectDatabaseId);
+  copySymbolProperty(source, snapshot, ObjectDeletedId);
 
-    // Metadata symbol. Copy arrays so the snapshot is not affected by mutations to the live meta's keys/tags.
-    copySymbolProperty(source, snapshot, MetaId, (meta: any) => ({
-      keys: [...(meta?.keys ?? [])],
-      tags: [...(meta?.tags ?? [])],
-    }));
+  // Parent reference (required for Obj.getParent to work on snapshots).
+  copySymbolProperty(source, snapshot, ParentId);
 
-    // Relation endpoint symbols.
-    copySymbolProperty(source, snapshot, RelationSourceDXNId);
-    copySymbolProperty(source, snapshot, RelationTargetDXNId);
-    copySymbolProperty(source, snapshot, RelationSourceId);
-    copySymbolProperty(source, snapshot, RelationTargetId);
-  }
+  // Metadata symbol. Copy arrays so the snapshot is not affected by mutations to the live meta's keys/tags.
+  copySymbolProperty(source, snapshot, MetaId, (meta: any) => ({
+    keys: [...(meta?.keys ?? [])],
+    tags: [...(meta?.tags ?? [])],
+  }));
+
+  // Relation endpoint symbols.
+  copySymbolProperty(source, snapshot, RelationSourceDXNId);
+  copySymbolProperty(source, snapshot, RelationTargetDXNId);
+  copySymbolProperty(source, snapshot, RelationSourceId);
+  copySymbolProperty(source, snapshot, RelationTargetId);
 
   return Object.freeze(snapshot) as T;
 };

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

@@ -0,0 +1,32 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+import { describe, expect, test } from 'vitest';
+
+import { DXN } from '@dxos/keys';
+
+import * as Type from '../../Type';
+import { EchoObjectSchema } from '../Entity';
+
+const Organization = Schema.Struct({
+  name: Schema.String,
+}).pipe(EchoObjectSchema(DXN.make('com.example.type.organization', '0.1.0')));
+
+type Organization = Type.InstanceType<typeof Organization>;
+
+describe('EchoObjectSchema DSL', () => {
+  test('type is a Type.Type entity', async () => {
+    expect(Schema.isSchema(Type.getSchema(Organization))).to.be.true;
+  });
+
+  test('static typename accessor', async () => {
+    expect(Type.getTypename(Organization)).to.eq('com.example.type.organization');
+  });
+
+  test('expect schema', async () => {
+    expect(SchemaAST.isTypeLiteral(Type.getSchema(Organization).ast)).to.be.true;
+  });
+});

package/src/internal/{object → Obj}/typed-object.ts

@@ -4,17 +4,17 @@
 
 import type * as Schema from 'effect/Schema';
 
-import { type TypeMeta } from '../annotations';
-import { type AnyEntity } from '../types';
+import { type TypeMeta } from '../Annotation';
+import { type AnyEntity } from '../common/types';
 
 /**
  * Definition for an object type that can be stored in an ECHO database.
  * Implements effect schema to define object properties.
  * Has a typename and version.
  *
- * In contrast to {@link EchoSchema} this definition is not recorded in the database.
+ * In contrast to a stored `Type.Type` entity, this definition is not recorded in the database.
  *
- * @deprecated Use `Type.Obj.Any` from `@dxos/echo` instead.
+ * @deprecated Use `Type.AnyObj` from `@dxos/echo` instead.
  */
 export interface TypedObject<A = any, I = any> extends TypeMeta, Schema.Schema<A, I> {}
 
@@ -22,7 +22,7 @@ export interface TypedObject<A = any, I = any> extends TypeMeta, Schema.Schema<A
  * Typed object that could be used as a prototype in class definitions.
  * This is an internal API type.
  *
- * @deprecated Use `Type.Obj.Any` from `@dxos/echo` instead.
+ * @deprecated Use `Type.AnyObj` from `@dxos/echo` instead.
  */
 export interface TypedObjectPrototype<A = any, I = any> extends TypedObject<A, I> {
   /** Type constructor. */