@dxos/echo 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/src/Obj.test.ts

@@ -0,0 +1,641 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expectTypeOf, test, expect } from 'vitest';
+
+import { EID } from '@dxos/keys';
+
+import * as Entity from './Entity';
+import { SnapshotKindId } from './internal';
+import * as Obj from './Obj';
+import * as Ref from './Ref';
+import * as Relation from './Relation';
+import { TestSchema } from './testing';
+
+describe('Obj', () => {
+  describe('make', () => {
+    test('generates a random id when none is provided', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      expect(obj.id).toBeDefined();
+      expect(obj.id.length).toBeGreaterThan(0);
+    });
+
+    test('uses the provided id at creation time', ({ expect }) => {
+      const a = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const b = Obj.make(TestSchema.Person, { name: 'Bob', id: a.id });
+      expect(b.id).toBe(a.id);
+    });
+
+    test('rejects an invalid id format', ({ expect }) => {
+      expect(() => Obj.make(TestSchema.Person, { name: 'Alice', id: 'not-a-ulid' })).toThrow(
+        /Invalid object id format/,
+      );
+    });
+  });
+
+  describe('getSnapshot', () => {
+    test('getSnapshot returns an immutable snapshot with SnapshotKindId', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      const snapshot = Obj.getSnapshot(obj);
+
+      // Snapshot has SnapshotKindId, not KindId.
+      expect(snapshot[SnapshotKindId]).toBe(Entity.Kind.Object);
+      expect((snapshot as any)[Entity.KindId]).toBeUndefined();
+      expect(Obj.isSnapshot(snapshot)).toBe(true);
+      expect(Relation.isSnapshot(snapshot)).toBe(false);
+      expect(Entity.isEntity(snapshot)).toBe(false);
+      expect(Entity.isSnapshot(snapshot)).toBe(true);
+
+      // Snapshot has same id and properties.
+      expect(snapshot.id).toBe(obj.id);
+      expect(snapshot.name).toBe('Test');
+    });
+
+    test('snapshot is frozen', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      const snapshot = Obj.getSnapshot(obj);
+
+      expect(Object.isFrozen(snapshot)).toBe(true);
+    });
+
+    test('read-only helpers work with both reactive and snapshot', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      const snapshot = Obj.getSnapshot(obj);
+
+      // getDXN - works with both.
+      expect(Obj.getURI(obj)).toBeDefined();
+      expect(Obj.getURI(snapshot)).toBeDefined();
+
+      // getTypename - works with both.
+      expect(Obj.getTypename(obj)).toBe('com.example.type.person');
+      expect(Obj.getTypename(snapshot)).toBe('com.example.type.person');
+
+      // getMeta - works with both.
+      expect(Obj.getMeta(obj)).toBeDefined();
+      expect(Obj.getMeta(snapshot)).toBeDefined();
+
+      // getKeys - works with both.
+      expect(Obj.getKeys(obj, 'test')).toEqual([]);
+      expect(Obj.getKeys(snapshot, 'test')).toEqual([]);
+
+      // isDeleted - works with both.
+      expect(Obj.isDeleted(obj)).toBe(false);
+      expect(Obj.isDeleted(snapshot)).toBe(false);
+
+      // version - works with both.
+      expect(Obj.version(obj)).toBeDefined();
+      expect(Obj.version(snapshot)).toBeDefined();
+
+      // toJSON - works with both.
+      expect(Obj.toJSON(obj)).toBeDefined();
+      expect(Obj.toJSON(snapshot)).toBeDefined();
+    });
+
+    test('reactive object has KindId, snapshot has SnapshotKindId', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      const snapshot = Obj.getSnapshot(obj);
+
+      // Verify at runtime that the brands are different.
+      expect(Entity.KindId in obj).toBe(true);
+      expect(SnapshotKindId in obj).toBe(false);
+      expect(SnapshotKindId in snapshot).toBe(true);
+      expect(Entity.KindId in snapshot).toBe(false);
+    });
+
+    test('getSnapshot preserves parent', ({ expect }) => {
+      const parent = Obj.make(TestSchema.Organization, { name: 'parent' });
+      const child = Obj.make(TestSchema.Person, { name: 'child' });
+      Obj.setParent(child, parent);
+
+      const snapshot = Obj.getSnapshot(child);
+
+      expect(Obj.getParent(child)).toBe(parent);
+      expect(Obj.getParent(snapshot)).toBe(parent);
+    });
+  });
+
+  describe('getURI', () => {
+    test('default returns EID', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const uri = Obj.getURI(obj);
+      expect(EID.isEID(uri)).toBe(true);
+    });
+
+    test("prefer: 'relative' returns local EID echo:/<id>", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const uri = Obj.getURI(obj, { prefer: 'relative' });
+      expect(uri).toMatch(/^echo:\/[^/]/);
+      expect(EID.isLocal(EID.parse(uri))).toBe(true);
+    });
+
+    test("prefer: 'relative' works with snapshot", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const snapshot = Obj.getSnapshot(obj);
+      expect(Obj.getURI(snapshot, { prefer: 'relative' })).toBe(Obj.getURI(obj, { prefer: 'relative' }));
+    });
+
+    test("prefer: 'named' returns dxn: URI when meta.key is set", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, {
+        [Obj.Meta]: { key: 'org.dxos.blueprint.webSearch' },
+        name: 'Alice',
+      });
+      const uri = Obj.getURI(obj, { prefer: 'named' });
+      expect(uri).toBe('dxn:org.dxos.blueprint.webSearch');
+    });
+
+    test("prefer: 'named' falls back to EID when meta.key is absent", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const uri = Obj.getURI(obj, { prefer: 'named' });
+      expect(EID.isEID(uri)).toBe(true);
+    });
+
+    test("prefer: 'named' handles key with hyphens (falls back to raw key URI)", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, {
+        [Obj.Meta]: { key: 'org.dxos.blueprint.web-search' },
+        name: 'Alice',
+      });
+      // Hyphens in the final DXN segment are invalid; falls back to the raw key as URI.
+      const uri = Obj.getURI(obj, { prefer: 'named' });
+      expect(uri).toBe('org.dxos.blueprint.web-search');
+    });
+
+    test("prefer: 'absolute' falls back to current EID when object has no database", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      // Without a database the space id is unknown; result is at least a valid EID.
+      const uri = Obj.getURI(obj, { prefer: 'absolute' });
+      expect(EID.isEID(uri)).toBe(true);
+    });
+
+    test("prefer: 'relative' returns the same local EID for reactive and snapshot", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const snapshot = Obj.getSnapshot(obj);
+      expect(Obj.getURI(snapshot, { prefer: 'relative' })).toBe(Obj.getURI(obj, { prefer: 'relative' }));
+    });
+
+    test("prefer: 'named' works the same on snapshot as on reactive (meta.key is preserved)", ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, {
+        [Obj.Meta]: { key: 'com.example.foo' },
+        name: 'Alice',
+      });
+      const snapshot = Obj.getSnapshot(obj);
+      expect(Obj.getURI(snapshot, { prefer: 'named' })).toBe(Obj.getURI(obj, { prefer: 'named' }));
+      expect(Obj.getURI(snapshot, { prefer: 'named' })).toBe('dxn:com.example.foo');
+    });
+  });
+
+  describe('snapshotOf', () => {
+    test('returns true for snapshot of matching schema', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      const snapshot = Obj.getSnapshot(obj);
+
+      expect(Obj.snapshotOf(TestSchema.Person, snapshot)).toBe(true);
+      expect(Obj.snapshotOf(TestSchema.Organization, snapshot)).toBe(false);
+    });
+
+    test('returns false for reactive object', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+
+      expect(Obj.snapshotOf(TestSchema.Person, obj)).toBe(false);
+    });
+
+    test('returns false for plain object with matching shape', ({ expect }) => {
+      const plain = { id: 'test', name: 'Test' };
+
+      expect(Obj.snapshotOf(TestSchema.Person, plain)).toBe(false);
+    });
+
+    test('curried form works', ({ expect }) => {
+      const snapshot = Obj.getSnapshot(Obj.make(TestSchema.Person, { name: 'Test' }));
+      const isPersonSnapshot = Obj.snapshotOf(TestSchema.Person);
+
+      expect(isPersonSnapshot(snapshot)).toBe(true);
+      expect(isPersonSnapshot({})).toBe(false);
+    });
+  });
+
+  describe('getKeys', () => {
+    const SOURCE = 'test-source';
+
+    test('returns keys from reactive object and snapshot', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      Obj.update(obj, (obj) => {
+        const meta = Obj.getMeta(obj);
+        meta.keys.push({ source: SOURCE, id: 'key-1' });
+        meta.keys.push({ source: SOURCE, id: 'key-2' });
+        meta.keys.push({ source: 'other', id: 'key-3' });
+      });
+
+      expect(Obj.getKeys(obj, SOURCE)).toHaveLength(2);
+      expect(Obj.getKeys(obj, SOURCE).map((k) => k.id)).toEqual(['key-1', 'key-2']);
+
+      const snapshot = Obj.getSnapshot(obj);
+      expect(Obj.getKeys(snapshot, SOURCE)).toHaveLength(2);
+      expect(Obj.getKeys(snapshot, SOURCE).map((k) => k.id)).toEqual(['key-1', 'key-2']);
+    });
+
+    test('throws for plain object without metadata', ({ expect }) => {
+      const plain = { id: 'plain-1', name: 'Plain' };
+      expect(() => Obj.getKeys(plain as any, SOURCE)).toThrow(/EntityMeta not found/);
+    });
+  });
+
+  describe('clone', () => {
+    test('clones object with same properties', ({ expect }) => {
+      const original = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        age: 30,
+      });
+
+      const cloned = Obj.clone(original);
+
+      expect(cloned).not.toBe(original);
+      expect(cloned.id).not.toBe(original.id);
+      expect(cloned.name).toBe(original.name);
+      expect(cloned.email).toBe(original.email);
+      expect(cloned.username).toBe(original.username);
+      expect(cloned.age).toBe(original.age);
+    });
+
+    test('cloned object is independent', ({ expect }) => {
+      const original = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+      });
+
+      const cloned = Obj.clone(original);
+
+      Obj.update(original, (original) => {
+        original.name = 'Bob';
+      });
+
+      expect(original.name).toBe('Bob');
+      expect(cloned.name).toBe('Alice');
+    });
+
+    test('clone with retainId option keeps original id', ({ expect }) => {
+      const original = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+      });
+
+      const cloned = Obj.clone(original, { retainId: true });
+
+      expect(cloned.id).toBe(original.id);
+      expect(cloned.name).toBe(original.name);
+    });
+
+    test('shallow clone does not clone referenced objects', ({ expect }) => {
+      const employer = Obj.make(TestSchema.Organization, {
+        name: 'DXOS',
+      });
+
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        employer: Ref.make(employer),
+      });
+
+      const cloned = Obj.clone(person);
+
+      expect(cloned.employer).toBe(person.employer);
+      expect(cloned.employer?.target).toBe(employer);
+      expect(cloned.employer?.target).toBe(person.employer?.target);
+
+      // Modifying the referenced object affects both
+      Obj.update(employer, (employer) => {
+        employer.name = 'Updated DXOS';
+      });
+
+      expect(cloned.employer?.target?.name).toBe('Updated DXOS');
+      expect(person.employer?.target?.name).toBe('Updated DXOS');
+    });
+
+    test('deep clone recursively clones referenced objects', ({ expect }) => {
+      const employer = Obj.make(TestSchema.Organization, {
+        name: 'DXOS',
+      });
+
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        employer: Ref.make(employer),
+      });
+
+      const cloned = Obj.clone(person, { deep: true });
+
+      expect(cloned.employer).not.toBe(person.employer);
+      expect(cloned.employer?.target).not.toBe(employer);
+      expect(cloned.employer?.target?.id).not.toBe(employer.id);
+      expect(cloned.employer?.target?.name).toBe(employer.name);
+
+      // Modifying the original referenced object does not affect the clone
+      Obj.update(employer, (employer) => {
+        employer.name = 'Updated DXOS';
+      });
+
+      expect(cloned.employer?.target?.name).toBe('DXOS');
+      expect(person.employer?.target?.name).toBe('Updated DXOS');
+    });
+
+    test('deep clone with nested references', ({ expect }) => {
+      const task1 = Obj.make(TestSchema.Task, {
+        title: 'Task 1',
+        description: 'First task',
+      });
+
+      const task2 = Obj.make(TestSchema.Task, {
+        title: 'Task 2',
+        description: 'Second task',
+        previous: Ref.make(task1),
+      });
+
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        tasks: [Ref.make(task1), Ref.make(task2)],
+      });
+
+      const cloned = Obj.clone(person, { deep: true });
+
+      expect(cloned.tasks).not.toBe(person.tasks);
+      expect(cloned.tasks?.length).toBe(2);
+      expect(cloned.tasks?.[0]?.target).not.toBe(task1);
+      expect(cloned.tasks?.[0]?.target?.id).not.toBe(task1.id);
+      expect(cloned.tasks?.[0]?.target?.title).toBe(task1.title);
+
+      expect(cloned.tasks?.[1]?.target).not.toBe(task2);
+      expect(cloned.tasks?.[1]?.target?.id).not.toBe(task2.id);
+      expect(cloned.tasks?.[1]?.target?.title).toBe(task2.title);
+
+      // Deep clone should also clone nested references
+      expect(cloned.tasks?.[1]?.target?.previous?.target).not.toBe(task1);
+      expect(cloned.tasks?.[1]?.target?.previous?.target?.id).not.toBe(task1.id);
+      expect(cloned.tasks?.[1]?.target?.previous?.target?.title).toBe(task1.title);
+    });
+
+    test('deep clone with optional reference', ({ expect }) => {
+      const employer = Obj.make(TestSchema.Organization, {
+        name: 'DXOS',
+      });
+
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        employer: Ref.make(employer),
+      });
+
+      const cloned = Obj.clone(person, { deep: true });
+
+      expect(cloned.employer).toBeDefined();
+      expect(cloned.employer?.target).toBeDefined();
+      expect(cloned.employer?.target?.name).toBe('DXOS');
+
+      // Test with undefined optional reference
+      const personWithoutEmployer = Obj.make(TestSchema.Person, {
+        name: 'Bob',
+        email: 'bob@example.com',
+        username: 'bob',
+      });
+
+      const clonedWithoutEmployer = Obj.clone(personWithoutEmployer, { deep: true });
+      expect(clonedWithoutEmployer.employer).toBeUndefined();
+    });
+
+    test('deep clone preserves nested object properties', ({ expect }) => {
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        address: {
+          city: 'San Francisco',
+          state: 'CA',
+          zip: '94102',
+          coordinates: {
+            lat: 37.7749,
+            lng: -122.4194,
+          },
+        },
+      });
+
+      const cloned = Obj.clone(person, { deep: true });
+
+      expect(cloned.address?.city).toBe('San Francisco');
+      expect(cloned.address?.state).toBe('CA');
+      expect(cloned.address?.zip).toBe('94102');
+      expect(cloned.address?.coordinates?.lat).toBe(37.7749);
+      expect(cloned.address?.coordinates?.lng).toBe(-122.4194);
+
+      // Modifying nested properties should be independent
+      Obj.update(person, (person) => {
+        person.address!.city = 'New York';
+      });
+
+      expect(cloned.address?.city).toBe('San Francisco');
+      expect(person.address?.city).toBe('New York');
+    });
+
+    test('deep clone with array of references', ({ expect }) => {
+      const task1 = Obj.make(TestSchema.Task, { title: 'Task 1' });
+      const task2 = Obj.make(TestSchema.Task, { title: 'Task 2' });
+      const task3 = Obj.make(TestSchema.Task, { title: 'Task 3' });
+
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        tasks: [Ref.make(task1), Ref.make(task2), Ref.make(task3)],
+      });
+
+      const cloned = Obj.clone(person, { deep: true });
+
+      expect(cloned.tasks?.length).toBe(3);
+      expect(cloned.tasks?.[0]?.target?.title).toBe('Task 1');
+      expect(cloned.tasks?.[1]?.target?.title).toBe('Task 2');
+      expect(cloned.tasks?.[2]?.target?.title).toBe('Task 3');
+
+      // All referenced tasks should be cloned
+      expect(cloned.tasks?.[0]?.target).not.toBe(task1);
+      expect(cloned.tasks?.[1]?.target).not.toBe(task2);
+      expect(cloned.tasks?.[2]?.target).not.toBe(task3);
+
+      // Modifying original tasks should not affect cloned ones
+      Obj.update(task1, (task1) => {
+        task1.title = 'Updated Task 1';
+      });
+
+      expect(cloned.tasks?.[0]?.target?.title).toBe('Task 1');
+      expect(person.tasks?.[0]?.target?.title).toBe('Updated Task 1');
+    });
+
+    test('deep clone with retainId option', ({ expect }) => {
+      const employer = Obj.make(TestSchema.Organization, {
+        name: 'DXOS',
+      });
+
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+        employer: Ref.make(employer),
+      });
+
+      const cloned = Obj.clone(person, { deep: true, retainId: true });
+
+      expect(cloned.id).toBe(person.id);
+      expect(cloned.employer?.target).not.toBe(employer);
+      // When retainId is true, nested objects also retain their IDs
+      expect(cloned.employer?.target?.id).toBe(employer.id);
+      expect(cloned.employer?.target?.name).toBe(employer.name);
+    });
+
+    test('clone preserves schema type', ({ expect }) => {
+      const person = Obj.make(TestSchema.Person, {
+        name: 'Alice',
+        email: 'alice@example.com',
+        username: 'alice',
+      });
+
+      const cloned = Obj.clone(person);
+
+      expect(Obj.instanceOf(TestSchema.Person, cloned)).toBe(true);
+      expect(Obj.getType(cloned)).toBe(Obj.getType(person));
+    });
+  });
+
+  describe('type-level tests', () => {
+    test('Obj.Unknown does not allow arbitrary property access', () => {
+      // Obj.Unknown only exposes `id` - no arbitrary properties.
+      expectTypeOf<Obj.Unknown>().toHaveProperty('id');
+      expectTypeOf<Obj.Unknown>().not.toHaveProperty('name');
+      expectTypeOf<Obj.Unknown>().not.toHaveProperty('foo');
+
+      // Accessing an unknown property should be a type error.
+      // This verifies that Obj.Unknown is NOT an index signature type.
+      type HasName = Obj.Unknown extends { name: unknown } ? true : false;
+      expectTypeOf<HasName>().toEqualTypeOf<false>();
+    });
+
+    test('Obj.Any allows arbitrary property access via index signature', () => {
+      // Obj.Any has an index signature allowing any string key.
+      expectTypeOf<Obj.Any>().toHaveProperty('id');
+
+      // Any string key returns `any`.
+      type AnyPropertyType = Obj.Any['anyArbitraryProperty'];
+      expectTypeOf<AnyPropertyType>().toBeAny();
+
+      // This verifies that Obj.Any IS an index signature type.
+      type HasIndexSignature = Obj.Any extends { [key: string]: any } ? true : false;
+      expectTypeOf<HasIndexSignature>().toEqualTypeOf<true>();
+    });
+
+    test('Obj.Unknown and Obj.Any are mutually assignable', () => {
+      // Both types are mutually assignable due to structural typing.
+      // The key difference is in property ACCESS, not assignability:
+      // - Obj.Unknown: cannot access arbitrary properties (no index signature)
+      // - Obj.Any: can access arbitrary properties (has [key: string]: any)
+      expectTypeOf<Obj.Unknown>().toMatchTypeOf<Obj.Any>();
+      expectTypeOf<Obj.Any>().toMatchTypeOf<Obj.Unknown>();
+    });
+  });
+
+  describe('Obj.updateFrom', () => {
+    test('returns false when values already match', () => {
+      const target = Obj.make(TestSchema.Organization, { name: 'Acme', properties: { region: 'EU' } });
+      const source = Obj.make(TestSchema.Organization, { name: 'Acme', properties: { region: 'EU' } });
+      Obj.update(target, (target) => {
+        expect(Obj.updateFrom(target, source)).toBe(false);
+      });
+    });
+
+    test('updates scalar and nested record fields on Organization', () => {
+      const target = Obj.make(TestSchema.Organization, {
+        name: 'Old',
+        properties: { a: '1' },
+      });
+      const source = Obj.make(TestSchema.Organization, {
+        name: 'New',
+        properties: { a: '2', b: '3' },
+      });
+      Obj.update(target, (target) => {
+        expect(Obj.updateFrom(target, source)).toBe(true);
+      });
+      expect(target.name).toBe('New');
+      expect(target.properties).toEqual({ a: '2', b: '3' });
+    });
+
+    test('compares employer refs by DXN and updates Person fields', () => {
+      const orgA = Obj.make(TestSchema.Organization, { name: 'A' });
+      const orgB = Obj.make(TestSchema.Organization, { name: 'B' });
+      const target = Obj.make(TestSchema.Person, {
+        name: 'Ann',
+        username: 'ann',
+        email: 'ann@x.test',
+        employer: Ref.make(orgA),
+        address: { city: 'X', state: 'Y', zip: '1', coordinates: { lat: 0, lng: 0 } },
+      });
+      const source = Obj.make(TestSchema.Person, {
+        name: 'Ann',
+        username: 'ann',
+        email: 'ann@x.test',
+        employer: Ref.make(orgB),
+        address: { city: 'Portland', state: 'OR', zip: '97201', coordinates: { lat: 45.5, lng: -122.6 } },
+      });
+      Obj.update(target, (target) => {
+        expect(Obj.updateFrom(target, source)).toBe(true);
+      });
+      expect(target.employer?.uri.toString()).toBe(Ref.make(orgB).uri.toString());
+      expect(target.address?.city).toBe('Portland');
+    });
+
+    test('updates array of task refs when DXNs differ', () => {
+      const t1 = Obj.make(TestSchema.Task, { title: 'One' });
+      const t2 = Obj.make(TestSchema.Task, { title: 'Two' });
+      const t3 = Obj.make(TestSchema.Task, { title: 'Three' });
+      const target = Obj.make(TestSchema.Person, {
+        name: 'Bob',
+        username: 'bob',
+        email: 'bob@x.test',
+        tasks: [Ref.make(t1), Ref.make(t2)],
+      });
+      const source = Obj.make(TestSchema.Person, {
+        name: 'Bob',
+        username: 'bob',
+        email: 'bob@x.test',
+        tasks: [Ref.make(t1), Ref.make(t3)],
+      });
+      Obj.update(target, (target) => {
+        expect(Obj.updateFrom(target, source)).toBe(true);
+      });
+      expect(target.tasks?.map((r) => r.uri)).toEqual(source.tasks?.map((r) => r.uri));
+    });
+
+    test('respects include option', () => {
+      const target = Obj.make(TestSchema.Organization, { name: 'Keep', properties: { x: '1' } });
+      const source = Obj.make(TestSchema.Organization, { name: 'Drop', properties: { x: '2' } });
+      Obj.update(target, (target) => {
+        expect(Obj.updateFrom(target, source, { include: ['properties'] })).toBe(true);
+      });
+      expect(target.name).toBe('Keep');
+      expect(target.properties).toEqual({ x: '2' });
+    });
+
+    test('respects exclude option', () => {
+      const target = Obj.make(TestSchema.Organization, { name: 'Old', properties: { x: '1' } });
+      const source = Obj.make(TestSchema.Organization, { name: 'New', properties: { x: '2' } });
+      Obj.update(target, (target) => {
+        expect(Obj.updateFrom(target, source, { exclude: ['name'] })).toBe(true);
+      });
+      expect(target.name).toBe('Old');
+      expect(target.properties).toEqual({ x: '2' });
+    });
+  });
+});