@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/src/internal/Obj/inspect.ts

@@ -6,8 +6,10 @@ import type { InspectOptionsStylized, inspect as inspectFn } from 'node:util';
 
 import { type CustomInspectFunction, inspectCustom } from '@dxos/debug';
 
-import { getTypeDXN } from '../Annotation';
-import { ATTR_META, ATTR_TYPE, type AnyEntity, MetaId } from '../common/types';
+import { getTypeURI } from '../Annotation';
+import { ATTR_TYPE, type AnyEntity } from '../common/types';
+import { ATTR_META } from '../common/types/meta';
+import { MetaId } from '../common/types/model-symbols';
 
 /*
  * @internal
@@ -37,7 +39,7 @@ const typedObjectInspectFunction: CustomInspectFunction<AnyEntity> = function (
   return inspect(
     {
       id,
-      [ATTR_TYPE]: getTypeDXN(this),
+      [ATTR_TYPE]: getTypeURI(this),
       ...props,
       [ATTR_META]: (this as any)[MetaId], // TODO(dmaretskyi): Couldn't use getMeta since that throw's if the object has no meta.
     },

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

@@ -2,25 +2,28 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { DXN } from '@dxos/keys';
+import { DXN, EID } from '@dxos/keys';
 
 import * as Obj from '../../Obj';
 import { TestSchema } from '../../testing';
-import { getSchemaDXN, getSchemaTypename, getTypeDXN, getTypename } from '../Annotation';
+import * as Type from '../../Type';
+import { getTypeURI, getTypename } from '../Annotation';
 import { getMetaChecked } from '../common/api';
-import { makeObject } from '../common/proxy';
-import { ATTR_TYPE, EntityKind, KindId, MetaId, TypeId, getSchema } from '../common/types';
-import { RelationSourceId, RelationTargetId, getObjectDXN } from '../Entity';
+import { ATTR_TYPE, EntityKind, KindId, TypeId, getSchema } from '../common/types';
+import { MetaId } from '../common/types/model-symbols';
+import { RelationSourceId, RelationTargetId, getObjectEchoUri } from '../Entity';
+import * as JsonSchema from '../JsonSchema';
 import { Ref, StaticRefResolver } from '../Ref';
 import { createObject } from './create-object';
 import { objectFromJSON, objectToJSON } from './json-serializer';
 
 describe('Object JSON serializer', () => {
   test('should serialize and deserialize object', async () => {
-    const contact = makeObject(TestSchema.Person, { name: 'Alice' });
-    Obj.change(contact, (contact) => {
+    const contact = Obj.make(TestSchema.Person, { name: 'Alice' });
+    Obj.update(contact, (contact) => {
       getMetaChecked(contact).keys.push({ id: '12345', source: 'example.com' });
     });
 
@@ -33,13 +36,13 @@ describe('Object JSON serializer', () => {
     const taskJson = objectToJSON(task);
 
     expect(contactJson.id).toBe(contact.id);
-    expect(contactJson[ATTR_TYPE]).toEqual(getSchemaDXN(TestSchema.Person)!.toString());
+    expect(contactJson[ATTR_TYPE]).toEqual(Type.getURI(TestSchema.Person).toString());
     expect(contactJson.name).toEqual('Alice');
 
     expect(taskJson.id).toBe(task.id);
-    expect(taskJson[ATTR_TYPE]).toEqual(getSchemaDXN(TestSchema.Task)!.toString());
+    expect(taskJson[ATTR_TYPE]).toEqual(Type.getURI(TestSchema.Task).toString());
     expect(taskJson.title).toEqual('Fix the tests');
-    expect(taskJson.assignee).toEqual({ '/': DXN.fromLocalObjectId(contact.id).toString() });
+    expect(taskJson.assignee).toEqual({ '/': EID.make({ entityId: contact.id }) });
 
     const refResolver = new StaticRefResolver()
       .addSchema(TestSchema.Person)
@@ -52,7 +55,7 @@ describe('Object JSON serializer', () => {
 
     expect(contactFromJson.id).toBe(contact.id);
     expect(contactFromJson.name).toBe('Alice');
-    expect((contactFromJson as any)[TypeId]).toEqual(getSchemaDXN(TestSchema.Person));
+    expect((contactFromJson as any)[TypeId]).toEqual(Type.getURI(TestSchema.Person));
     expect((contactFromJson as any)[KindId]).toBe(EntityKind.Object);
     expect((contactFromJson as any)[RelationSourceId]).toBeUndefined();
     expect((contactFromJson as any)[RelationTargetId]).toBeUndefined();
@@ -63,23 +66,25 @@ describe('Object JSON serializer', () => {
           source: 'example.com',
         },
       ],
+      tags: [],
+      annotations: {},
     });
-    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(TestSchema.Person);
+    expect(getTypeURI(contactFromJson)?.toString()).toBe(Type.getURI(TestSchema.Person).toString());
+    expect(getTypename(contactFromJson)).toBe(Type.getTypename(TestSchema.Person));
+    expect(getObjectEchoUri(contactFromJson)?.toString()).toEqual(getObjectEchoUri(contact)?.toString());
+    expect(getSchema(contactFromJson)).toEqual(Type.getSchema(TestSchema.Person));
 
     expect(taskFromJson.id).toBe(task.id);
     expect(taskFromJson.title).toBe('Fix the tests');
-    expect(taskFromJson.assignee!.dxn).toEqual(DXN.fromLocalObjectId(contact.id));
+    expect(taskFromJson.assignee!.uri).toEqual(EID.make({ entityId: contact.id }));
     expect(taskFromJson.assignee!.target).toEqual(contact);
     expect(await taskFromJson.assignee!.load()).toEqual(contact);
-    expect((taskFromJson as any)[TypeId]).toEqual(getSchemaDXN(TestSchema.Task));
+    expect((taskFromJson as any)[TypeId]).toEqual(Type.getURI(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(TestSchema.Task);
+    expect((taskFromJson as any)[MetaId]).toEqual({ keys: [], tags: [], annotations: {} });
+    expect(getSchema(taskFromJson)).toEqual(Type.getSchema(TestSchema.Task));
   });
 
   test('serialize with unresolved schema', async () => {
@@ -90,9 +95,20 @@ describe('Object JSON serializer', () => {
     expect(contactFromJson.id).toBe(contact.id);
     expect(contactFromJson.name).toBe('Alice');
     expect(getSchema(contactFromJson)).toBeUndefined();
-    expect(getTypename(contactFromJson)).toEqual(getSchemaTypename(TestSchema.Person));
-    expect(getObjectDXN(contactFromJson)).toEqual(getObjectDXN(contact));
-    expect(getTypeDXN(contactFromJson)).toEqual(getSchemaDXN(TestSchema.Person));
+    expect(getTypename(contactFromJson)).toEqual(Type.getTypename(TestSchema.Person));
+    expect(getObjectEchoUri(contactFromJson)).toEqual(getObjectEchoUri(contact));
+    expect(getTypeURI(contactFromJson)).toEqual(Type.getURI(TestSchema.Person));
+  });
+
+  test('upgrades bare string tags to encoded references on deserialize', async () => {
+    const expando = Obj.make(TestSchema.Expando, { message: 'hi' });
+    const json = objectToJSON(expando) as any;
+    // Simulate data serialized before the tags-as-refs migration: bare id strings.
+    json['@meta'] = { keys: [], tags: ['echo:/TAGLEGACY'] };
+
+    const fromJson = (await objectFromJSON(json)) as any;
+    // Decodes to a materialized `Ref` (the shared ref codec), not a raw encoded reference.
+    expect(fromJson[MetaId].tags.map((ref: any) => ref.uri)).toEqual(['echo:/TAGLEGACY']);
   });
 
   test('deserializes expando without leaking internal json keys', async () => {
@@ -117,4 +133,67 @@ describe('Object JSON serializer', () => {
     expect(expandoFromJson.message).toBe('local-only');
     expect((expandoFromJson as any)[ATTR_TYPE]).toBeUndefined();
   });
+
+  // `objectFromJSON` is the deserialization path for queue messages and devtools
+  // round-trips. For persisted `Type.Type` entities it must stamp `KindId = Type`
+  // (not Object), mirroring the kind resolution that `createObject` does for the
+  // in-memory path. Otherwise `Filter.type(Type.Type)` / `Type.isType` skip them.
+  describe('Type.Type round-trip', () => {
+    test('preserves KindId=Type for a persisted Type.Type entity', async ({ expect }) => {
+      const typeEntity = Type.makeObjectFromJsonSchema({
+        typename: 'com.example.type.regression',
+        version: '0.1.0',
+        jsonSchema: JsonSchema.toJsonSchema(Schema.Struct({ field: Schema.Number })),
+        name: 'Regression Type',
+      });
+
+      const typeJson = objectToJSON(typeEntity as any);
+      const refResolver = new StaticRefResolver().addSchema(Type.Type);
+      const reconstructed = (await objectFromJSON(typeJson, { refResolver })) as any;
+
+      expect(reconstructed[KindId]).toBe(EntityKind.Type);
+      expect(Type.isType(reconstructed)).toBe(true);
+      // `typename` lives in `EntityMeta.key` on persisted Type.Type entities
+      // — surfaced via `Type.getTypename`.
+      expect(Type.getTypename(reconstructed)).toBe('com.example.type.regression');
+    });
+  });
+
+  describe('Uint8Array', () => {
+    const Blob = Schema.Struct({
+      name: Schema.String,
+      bytes: Schema.Uint8ArrayFromSelf,
+    }).pipe(Type.makeObject(DXN.make('com.example.type.blob', '0.1.0')));
+    type Blob = Type.InstanceType<typeof Blob>;
+
+    test('round-trips Uint8Array field through JSON with schema', async ({ expect }) => {
+      const bytes = new Uint8Array([0, 1, 2, 3, 250, 251, 252, 253, 254, 255]);
+      const blob = Obj.make(Blob, { name: 'blob', bytes });
+
+      const blobJson = objectToJSON(blob);
+      // JSON must round-trip through stringify/parse without loss.
+      const roundTripped = JSON.parse(JSON.stringify(blobJson));
+
+      const refResolver = new StaticRefResolver().addSchema(Blob);
+      const blobFromJson = (await objectFromJSON(roundTripped, { refResolver })) as Blob;
+
+      expect(blobFromJson.name).toBe('blob');
+      expect(blobFromJson.bytes).toBeInstanceOf(Uint8Array);
+      expect(Array.from(blobFromJson.bytes)).toEqual(Array.from(bytes));
+    });
+
+    test('round-trips Uint8Array field through JSON without schema resolver', async ({ expect }) => {
+      const bytes = new Uint8Array([10, 20, 30, 40, 50]);
+      const blob = Obj.make(Blob, { name: 'blob', bytes });
+
+      const blobJson = objectToJSON(blob);
+      const roundTripped = JSON.parse(JSON.stringify(blobJson));
+
+      const blobFromJson = (await objectFromJSON(roundTripped)) as Blob;
+
+      expect(blobFromJson.name).toBe('blob');
+      expect(blobFromJson.bytes).toBeInstanceOf(Uint8Array);
+      expect(Array.from(blobFromJson.bytes)).toEqual(Array.from(bytes));
+    });
+  });
 });

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

@@ -5,39 +5,40 @@
 import * as Schema from 'effect/Schema';
 
 import { raise } from '@dxos/debug';
-import { type EncodedReference, ObjectStructure, isEncodedReference } from '@dxos/echo-protocol';
+import { type EncodedReference, EntityStructure, 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 { EID, EntityId, 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 '../Annotation';
+import { getTypeAnnotation, getTypeURI, setTypename } from '../Annotation';
 import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../common/proxy';
 import {
-  ATTR_META,
   ATTR_PARENT,
   ATTR_TYPE,
   type AnyEntity,
   EntityKind,
   KindId,
-  MetaId,
-  ObjectMetaSchema,
   ParentId,
   setSchema,
+  setType,
 } from '../common/types';
+import { ATTR_META, EntityMetaSchema } from '../common/types/meta';
+import { MetaId } from '../common/types/model-symbols';
 import {
   ATTR_DELETED,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
-  ATTR_SELF_DXN,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
   ObjectDatabaseId,
   type ObjectJSON,
   RelationSourceDXNId,
   RelationSourceId,
   RelationTargetDXNId,
   RelationTargetId,
-  SelfDXNId,
+  SelfURIId,
   assertObjectModel,
 } from '../Entity';
 import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../Ref';
@@ -62,7 +63,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);
 };
@@ -75,27 +76,27 @@ export const objectToJSON = <T extends AnyEntity>(obj: T): SerializedObject<T> =
  *
  * @param jsonData - JSON representation of the object.
  * @param options.refResolver - Resolver for references.
- * @param options.dxn - Override object DXN.
+ * @param options.uri - Override object URI.
  * @param options.database - Database to associate with the object.
  */
 export const objectFromJSON = async (
   jsonData: unknown,
   {
     refResolver,
-    dxn,
+    uri,
     database,
     parent,
-  }: { refResolver?: RefResolver; dxn?: DXN; database?: Database.Database; parent?: Obj.Unknown } = {},
+  }: { 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 = stripInternalJsonKeys(jsonData);
+  const decodedInput = restoreUint8Arrays(stripInternalJsonKeys(jsonData));
 
   let obj: any;
   if (schema != null) {
@@ -107,17 +108,26 @@ export const objectFromJSON = async (
     obj = decodeGeneric(decodedInput, { refResolver });
   }
 
-  invariant(ObjectId.isValid(obj.id), 'Invalid object id');
+  invariant(EntityId.isValid(obj.id), 'Invalid object id');
   setTypename(obj, type);
   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;
@@ -128,29 +138,37 @@ 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') {
-    const meta = await ObjectMetaSchema.pipe(Schema.decodeUnknownPromise)(jsonData[ATTR_META]);
+    const meta = await EntityMetaSchema.pipe(Schema.decodeUnknownPromise)(normalizeMeta(jsonData[ATTR_META]));
     invariant(Array.isArray(meta.keys));
     defineHiddenProperty(obj, MetaId, meta);
   } else {
     defineHiddenProperty(obj, MetaId, {
       keys: [],
+      tags: [],
+      annotations: {},
     });
   }
 
   if (jsonData[ATTR_PARENT]) {
-    const parentDxn = DXN.parse(jsonData[ATTR_PARENT]);
+    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) {
@@ -161,12 +179,30 @@ export const objectFromJSON = async (
   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;
 };
 
+/**
+ * Backfills required meta fields and upgrades legacy `tags` (bare URI strings) to encoded references
+ * so serialized data produced before the tags-as-refs migration still decodes.
+ */
+const normalizeMeta = (meta: any): any => {
+  const tags = Array.isArray(meta?.tags)
+    ? meta.tags.map((tag: unknown) => (typeof tag === 'string' ? { '/': URI.make(tag) } : tag))
+    : [];
+  // Coalesce required fields so explicit `undefined` in legacy input doesn't override the defaults.
+  return {
+    ...meta,
+    keys: Array.isArray(meta?.keys) ? meta.keys : [],
+    tags,
+    annotations: meta?.annotations ?? {},
+  };
+};
+
 const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }) => {
   const props = stripInternalJsonKeys(jsonData);
 
@@ -174,17 +210,33 @@ const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }
     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
@@ -206,17 +258,21 @@ 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
+ * Convert EntityStructure to JSON data for indexing.
+ * Different from {@link objectToJSON} as it takes the internal {@link EntityStructure} representation directly
  */
-export const objectStructureToJson = (objectId: string, structure: ObjectStructure): Obj.JSON => {
+export const objectStructureToJson = (objectId: EntityId, structure: EntityStructure): Obj.JSON => {
+  const typeRef = EntityStructure.getTypeReference(structure)?.['/'];
+  const parent = EntityStructure.getParent(structure)?.['/'];
+  const source = EntityStructure.getRelationSource(structure)?.['/'];
+  const target = EntityStructure.getRelationTarget(structure)?.['/'];
   return {
     ...structure.data,
     id: objectId,
-    [ATTR_TYPE]: (ObjectStructure.getTypeReference(structure)?.['/'] ?? '') as DXN.String,
-    [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_TYPE]: typeRef ? URI.make(typeRef) : undefined,
+    [ATTR_DELETED]: EntityStructure.isDeleted(structure),
+    [ATTR_PARENT]: parent !== undefined ? EID.tryParse(parent) : undefined,
+    [ATTR_RELATION_SOURCE]: source !== undefined ? EID.tryParse(source) : undefined,
+    [ATTR_RELATION_TARGET]: target !== undefined ? EID.tryParse(target) : undefined,
   };
 };

package/src/internal/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, (person) => Obj.setValue(person, ['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, (person) => Obj.setValue(person, ['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, (person) => Obj.setValue(person, ['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,16 +62,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, (container) => {
+    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);
@@ -88,7 +85,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (person) => Obj.setValue(person, ['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, (person) => Obj.setValue(person, ['address', 'city'], 'NYC'));
+    Obj.update(person, (person) => Obj.setValue(person, ['address', 'city'], 'NYC'));
 
     expect(person.address).toBeDefined();
     expect(person.address?.city).toBe('NYC');
@@ -114,7 +111,7 @@ describe('Obj.setValue', () => {
     });
 
     let result: any;
-    Obj.change(person, (person) => {
+    Obj.update(person, (person) => {
       result = Obj.setValue(person, ['age'], 30);
     });
 
@@ -129,7 +126,7 @@ describe('Obj.setValue', () => {
       age: 25,
     });
 
-    Obj.change(person, (person) => Obj.setValue(person, ['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, (person) => Obj.setValue(person, ['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,16 +148,11 @@ 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, (matrix) => {
+    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);
@@ -180,7 +172,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (person) => {
+    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, (person) => Obj.setValue(person, ['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, (container) => Obj.setValue(container, ['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, (todoList) => Obj.setValue(todoList, ['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, (container) => Obj.setValue(container, ['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('');