@dxos/echo-atom 0.8.4-main.d05673bc65 → 0.8.4-main.d9fc60f731

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-atom",
-  "version": "0.8.4-main.d05673bc65",
+  "version": "0.8.4-main.d9fc60f731",
   "description": "Effect Atom wrappers for ECHO objects with explicit subscriptions.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "DXOS.org",
   "sideEffects": false,
   "type": "module",
@@ -20,27 +20,25 @@
     }
   },
   "types": "dist/types/src/index.d.ts",
-  "typesVersions": {
-    "*": {}
-  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@effect-atom/atom": "^0.5.1",
-    "@dxos/echo": "0.8.4-main.d05673bc65",
-    "@dxos/util": "0.8.4-main.d05673bc65",
-    "@dxos/echo-db": "0.8.4-main.d05673bc65",
-    "@dxos/invariant": "0.8.4-main.d05673bc65"
+    "@effect-atom/atom": "^0.5.3",
+    "@dxos/echo-db": "0.8.4-main.d9fc60f731",
+    "@dxos/util": "0.8.4-main.d9fc60f731",
+    "@dxos/invariant": "0.8.4-main.d9fc60f731",
+    "@dxos/echo": "0.8.4-main.d9fc60f731"
   },
   "devDependencies": {
-    "effect": "3.19.16",
-    "@dxos/random": "0.8.4-main.d05673bc65",
-    "@dxos/test-utils": "0.8.4-main.d05673bc65"
+    "effect": "3.21.2",
+    "@dxos/test-utils": "0.8.4-main.d9fc60f731",
+    "@dxos/context": "0.8.4-main.d9fc60f731",
+    "@dxos/random": "0.8.4-main.d9fc60f731"
   },
   "peerDependencies": {
-    "effect": "3.19.16"
+    "effect": "3.21.2"
   },
   "publishConfig": {
     "access": "public"

package/src/atom.test.ts

@@ -6,9 +6,9 @@ import * as Registry from '@effect-atom/atom/Registry';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
 import { Obj, Ref } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
 import { createObject } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { TestSchema } from '@dxos/echo/testing';
 
 import * as AtomObj from './atom';
 
@@ -55,7 +55,7 @@ describe('Echo Atom - Basic Functionality', () => {
     expect(registry.get(emailAtom)).toBe('test@example.com');
   });
 
-  test('atom updates when object is mutated via Obj.change', () => {
+  test('atom updates when object is mutated via Obj.update', () => {
     const obj = createObject(
       Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
     );
@@ -72,9 +72,9 @@ describe('Echo Atom - Basic Functionality', () => {
       { immediate: true },
     );
 
-    // Mutate object via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Mutate object via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     // Subscription should have fired: immediate + update.
@@ -85,7 +85,7 @@ describe('Echo Atom - Basic Functionality', () => {
     expect(obj.name).toBe('Updated');
   });
 
-  test('property atom supports updater pattern via Obj.change', () => {
+  test('property atom supports updater pattern via Obj.update', () => {
     const obj = createObject(
       Obj.make(TestSchema.Task, {
         title: 'Task',
@@ -104,9 +104,9 @@ describe('Echo Atom - Basic Functionality', () => {
       { immediate: true },
     );
 
-    // Update through Obj.change.
-    Obj.change(obj, (o) => {
-      o.title = (o.title ?? '') + ' Updated';
+    // Update through Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.title = (obj.title ?? '') + ' Updated';
     });
 
     // Subscription should have fired: immediate + update.
@@ -140,8 +140,8 @@ describe('Echo Atom - Basic Functionality', () => {
     expect(propertyUpdateCount).toBe(1);
 
     // Mutate the standalone object.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated Standalone';
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated Standalone';
     });
 
     // Both atoms should have received updates.
@@ -244,8 +244,8 @@ describe('Echo Atom - Referential Equality', () => {
     expect(updateCount).toBe(1);
 
     // Mutate the object.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     // The subscription should still work.
@@ -276,8 +276,8 @@ describe('Echo Atom - Referential Equality', () => {
     expect(updateCount).toBe(1);
 
     // Mutate the specific property.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     // The subscription should still work.

package/src/atom.ts

@@ -8,7 +8,7 @@ import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
 import * as Option from 'effect/Option';
 
-import { type Entity, Obj, Ref, Relation } from '@dxos/echo';
+import { Entity, Obj, Ref, Relation } from '@dxos/echo';
 import { assertArgument } from '@dxos/invariant';
 
 import { loadRefTarget } from './ref-utils';
@@ -130,7 +130,12 @@ export function make<T extends Entity.Unknown>(
 
   // At this point, objOrRef is definitely T (not a Ref).
   const obj = objOrRef as T;
-  assertArgument(Obj.isObject(obj) || Relation.isRelation(obj), 'obj', 'Object must be a reactive object');
+  // Accept any kind of entity (Obj, Relation, or persisted Type) — the
+  // reactive subscription only needs `[KindId]` to be set; the proxy machinery
+  // is kind-agnostic. Narrowing to Obj/Relation here used to throw for type
+  // entities returned by the schema registry (e.g. persisted RoastLog), which
+  // broke the schema-node connector in plugin-space.
+  assertArgument(Entity.isEntity(obj), 'obj', 'Object must be a reactive object');
 
   // TODO(dmaretskyi): Fix echo types during review.
   return objectFamily(obj as any);
@@ -161,7 +166,6 @@ export function makeProperty<T extends Obj.Unknown, K extends keyof T>(
   }
 
   assertArgument(Obj.isObject(obj), 'obj', 'Object must be a reactive object');
-  assertArgument(key in obj, 'key', 'Property must exist on object');
   return propertyFamily(obj)(key);
 }
 
@@ -189,7 +193,9 @@ const refWithReactiveFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T
   const effect = (get: Atom.Context) =>
     Effect.gen(function* () {
       const snapshot = get(make(ref));
-      if (snapshot == null) return undefined;
+      if (snapshot == null) {
+        return undefined;
+      }
       const option = yield* Obj.getReactiveOption(snapshot);
       return Option.getOrElse(option, () => undefined);
     });
@@ -203,7 +209,7 @@ const refWithReactiveFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T
 /**
  * Like {@link make} but returns the live reactive object instead of a snapshot.
  * Same input: Obj or Ref.Ref. Same output shape: Atom that updates when the object mutates.
- * Prefer {@link make} (snapshot) unless you need the live Obj.Obj for generic mutations (e.g. Obj.change).
+ * Prefer {@link make} (snapshot) unless you need the live Obj.Obj for generic mutations (e.g. Obj.update).
  *
  * @param objOrRef - The reactive object or ref.
  * @returns An atom that returns the live object. Returns undefined for refs (async loading) or undefined input.

package/src/batching.test.ts

@@ -6,13 +6,13 @@ import * as Registry from '@effect-atom/atom/Registry';
 import { describe, expect, test } from 'vitest';
 
 import { Obj } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
 import { createObject } from '@dxos/echo-db';
+import { TestSchema } from '@dxos/echo/testing';
 
 import * as AtomObj from './atom';
 
 describe('Echo Atom - Batch Updates', () => {
-  test('multiple updates to same object atom in single Obj.change fire single update', () => {
+  test('multiple updates to same object atom in single Obj.update fire single update', () => {
     const obj = createObject(
       Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
     );
@@ -33,14 +33,14 @@ describe('Echo Atom - Batch Updates', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1); // Verify immediate update fired.
 
-    // Make multiple updates to the same object in a single Obj.change call.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated1';
-      o.email = 'updated@example.com';
-      o.username = 'updated';
+    // Make multiple updates to the same object in a single Obj.update call.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated1';
+      obj.email = 'updated@example.com';
+      obj.username = 'updated';
     });
 
-    // Should have fired once for initial + once for the Obj.change (not once per property update).
+    // Should have fired once for initial + once for the Obj.update (not once per property update).
     expect(updateCount).toBe(2);
 
     // Verify final state.
@@ -50,7 +50,7 @@ describe('Echo Atom - Batch Updates', () => {
     expect(finalValue.username).toBe('updated');
   });
 
-  test('multiple separate Obj.change calls fire separate updates', () => {
+  test('multiple separate Obj.update calls fire separate updates', () => {
     const obj = createObject(
       Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
     );
@@ -71,18 +71,18 @@ describe('Echo Atom - Batch Updates', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1);
 
-    // Make multiple separate Obj.change calls.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated1';
+    // Make multiple separate Obj.update calls.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated1';
     });
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
-    Obj.change(obj, (o) => {
-      o.username = 'updated';
+    Obj.update(obj, (obj) => {
+      obj.username = 'updated';
     });
 
-    // Should have fired once for initial + once per Obj.change call.
+    // Should have fired once for initial + once per Obj.update call.
     expect(updateCount).toBe(4);
 
     // Verify final state.
@@ -92,7 +92,7 @@ describe('Echo Atom - Batch Updates', () => {
     expect(finalValue.username).toBe('updated');
   });
 
-  test('multiple updates to same property atom in single Obj.change fire single update', () => {
+  test('multiple updates to same property atom in single Obj.update fire single update', () => {
     const obj = createObject(
       Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
     );
@@ -113,14 +113,14 @@ describe('Echo Atom - Batch Updates', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1);
 
-    // Make multiple updates to the same property in a single Obj.change call.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated1';
-      o.name = 'Updated2';
-      o.name = 'Updated3';
+    // Make multiple updates to the same property in a single Obj.update call.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated1';
+      obj.name = 'Updated2';
+      obj.name = 'Updated3';
     });
 
-    // Should have fired once for initial + once for the Obj.change (not once per assignment).
+    // Should have fired once for initial + once for the Obj.update (not once per assignment).
     expect(updateCount).toBe(2);
 
     // Verify final state.

package/src/query-atom.test.ts

@@ -6,11 +6,10 @@ import * as Registry from '@effect-atom/atom/Registry';
 import * as Schema from 'effect/Schema';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Obj, type QueryResult, Type } from '@dxos/echo';
-import { Filter, Query } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
-import { type EchoDatabase } from '@dxos/echo-db';
+import { DXN, Filter, Obj, Query, type QueryResult, Type } from '@dxos/echo';
+import { type EchoDatabase, makeRegistry } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { TestSchema } from '@dxos/echo/testing';
 import { SpaceId } from '@dxos/keys';
 
 import * as AtomQuery from './query-atom';
@@ -21,13 +20,12 @@ import * as AtomQuery from './query-atom';
 const TestItem = Schema.Struct({
   name: Schema.String,
   value: Schema.Number,
-}).pipe(
-  Type.object({
-    typename: 'com.example.type.test-item',
-    version: '0.1.0',
-  }),
-);
-type TestItem = Schema.Schema.Type<typeof TestItem>;
+}).pipe(Type.makeObject(DXN.make('com.example.type.testItem', '0.1.0')));
+type TestItem = Type.InstanceType<typeof TestItem>;
+
+const TestItem2 = Schema.Struct({
+  title: Schema.String,
+}).pipe(Type.makeObject(DXN.make('com.example.type.testItem2', '0.1.0')));
 
 describe('AtomQuery', () => {
   let testBuilder: EchoTestBuilder;
@@ -202,6 +200,55 @@ describe('AtomQuery', () => {
   });
 });
 
+describe('AtomQuery with registry', () => {
+  let atomRegistry: Registry.Registry;
+
+  beforeEach(() => {
+    atomRegistry = Registry.make();
+  });
+
+  test('AtomQuery.make memoizes per registry instance', () => {
+    const registry = makeRegistry({ initial: [TestItem] });
+
+    // Same registry + filter must yield the same atom instance. Otherwise reactive
+    // connectors re-create the atom on every recompute, which destabilizes the
+    // effect-atom dependency graph and loops synchronously (the type-create freeze).
+    const atom1 = AtomQuery.make(registry, Filter.type(Type.Type));
+    const atom2 = AtomQuery.make(registry, Filter.type(Type.Type));
+    expect(atom1).toBe(atom2);
+
+    // A different registry instance must yield a different atom.
+    const otherRegistry = makeRegistry({ initial: [TestItem] });
+    expect(AtomQuery.make(otherRegistry, Filter.type(Type.Type))).not.toBe(atom1);
+  });
+
+  test('AtomQuery.make queries registry type entities', () => {
+    const registry = makeRegistry({ initial: [TestItem] });
+
+    const atom = AtomQuery.make(registry, Filter.type(Type.Type));
+    const results = atomRegistry.get(atom);
+
+    expect(results.map((type) => Type.getTypename(type))).toContain('com.example.type.testItem');
+  });
+
+  test('AtomQuery.make updates when registry contents change', () => {
+    const registry = makeRegistry({ initial: [TestItem] });
+
+    const atom = AtomQuery.make(registry, Filter.type(Type.Type));
+    expect(atomRegistry.get(atom)).toHaveLength(1);
+
+    let updateCount = 0;
+    atomRegistry.subscribe(atom, () => {
+      updateCount++;
+    });
+
+    registry.add([TestItem2]);
+
+    expect(updateCount).toBeGreaterThan(0);
+    expect(atomRegistry.get(atom)).toHaveLength(2);
+  });
+});
+
 describe('AtomQuery with queues', () => {
   let testBuilder: EchoTestBuilder;
   let registry: Registry.Registry;

package/src/query-atom.ts

@@ -4,11 +4,11 @@
 
 import { Atom } from '@effect-atom/atom';
 
-import { DXN, Database, type Entity, type Filter, Query, type QueryResult } from '@dxos/echo';
+import { Database, type Entity, type Filter, Query, type QueryResult, Registry, URI } from '@dxos/echo';
 import { WeakDictionary } from '@dxos/util';
 
 /**
- * Create a self-updating atom from an existing QueryResult.
+ * Create a self-updating atom from any QueryResult (e.g. schema registry queries).
  * Internally subscribes to queryResult and uses get.setSelf to update.
  * Cleanup is handled via get.addFinalizer.
  *
@@ -17,18 +17,13 @@ import { WeakDictionary } from '@dxos/util';
  * @param queryResult - The QueryResult to wrap.
  * @returns An atom that automatically updates when query results change.
  */
-export const fromQuery = <T extends Entity.Unknown>(queryResult: QueryResult.QueryResult<T>): Atom.Atom<T[]> =>
+export const fromQuery = <T>(queryResult: QueryResult.QueryResult<T>): Atom.Atom<T[]> =>
   Atom.make((get) => {
-    // TODO(wittjosiah): Consider subscribing to individual objects here as well, and grabbing their snapshots.
-    // Subscribe to QueryResult changes.
     const unsubscribe = queryResult.subscribe(() => {
-      get.setSelf(queryResult.results);
+      get.setSelf(queryResult.runSync());
     });
-
-    // Register cleanup for when atom is no longer used.
     get.addFinalizer(unsubscribe);
-
-    return queryResult.results;
+    return queryResult.runSync();
   });
 
 // Registry: key → Queryable (WeakRef with auto-cleanup when GC'd).
@@ -73,9 +68,13 @@ const getQueryableIdentifier = (queryable: Database.Queryable): string => {
   if (Database.isDatabase(queryable)) {
     return queryable.spaceId;
   }
-  // Queue or similar: use dxn if it's a DXN instance.
-  if ('dxn' in queryable && queryable.dxn instanceof DXN) {
-    return queryable.dxn.toString();
+  // Registry: use its stable per-instance id.
+  if (Registry.isRegistry(queryable)) {
+    return queryable.id;
+  }
+  // Queue or similar: use uri if it's a URI (EID or DXN).
+  if ('uri' in queryable && URI.isURI(queryable.uri)) {
+    return queryable.uri;
   }
   // Fallback: use id if it's a string.
   if ('id' in queryable && typeof queryable.id === 'string') {

package/src/reactivity.test.ts

@@ -6,8 +6,8 @@ import * as Registry from '@effect-atom/atom/Registry';
 import { describe, expect, test } from 'vitest';
 
 import { Obj } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
 import { createObject } from '@dxos/echo-db';
+import { TestSchema } from '@dxos/echo/testing';
 import { arrayMove } from '@dxos/util';
 
 import * as AtomObj from './atom';
@@ -28,9 +28,9 @@ describe('Echo Atom - Reactivity', () => {
     // Subscribe to enable reactivity.
     registry.subscribe(atom, () => {});
 
-    // Update the object via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update the object via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     const updatedSnapshot = registry.get(atom);
@@ -50,9 +50,9 @@ describe('Echo Atom - Reactivity', () => {
     // Subscribe to enable reactivity.
     registry.subscribe(atom, () => {});
 
-    // Update the property via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update the property via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
 
     expect(registry.get(atom)).toBe('Updated');
@@ -82,9 +82,9 @@ describe('Echo Atom - Reactivity', () => {
       emailUpdateCount++;
     });
 
-    // Update only email property via Obj.change.
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    // Update only email property via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
 
     // Name atom should NOT have changed.
@@ -109,10 +109,10 @@ describe('Echo Atom - Reactivity', () => {
     registry.subscribe(nameAtom, () => {});
     registry.subscribe(emailAtom, () => {});
 
-    // Update multiple properties via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
-      o.email = 'updated@example.com';
+    // Update multiple properties via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
+      obj.email = 'updated@example.com';
     });
 
     expect(registry.get(nameAtom)).toBe('Updated');
@@ -140,15 +140,15 @@ describe('Echo Atom - Reactivity', () => {
     const initialCount = updateCount;
     expect(initialCount).toBe(1);
 
-    // Update object via Obj.change.
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    // Update object via Obj.update.
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
-    Obj.change(obj, (o) => {
-      o.email = 'updated@example.com';
+    Obj.update(obj, (obj) => {
+      obj.email = 'updated@example.com';
     });
 
-    // Updates fire through Obj.subscribe (one per Obj.change call).
+    // Updates fire through Obj.subscribe (one per Obj.update call).
     expect(updateCount).toBe(initialCount + 2);
 
     // Verify final state - returns snapshot (plain object).
@@ -167,8 +167,8 @@ describe('Echo Atom - Reactivity', () => {
     });
 
     actions.push('before');
-    Obj.change(obj, (o) => {
-      o.name = 'Updated';
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
     });
     actions.push('after');
 
@@ -191,8 +191,8 @@ describe('Echo Atom - Reactivity', () => {
     });
 
     actions.push('before');
-    Obj.change(obj, (o) => {
-      o.stringArray!.splice(1, 1);
+    Obj.update(obj, (obj) => {
+      obj.stringArray!.splice(1, 1);
     });
     actions.push('after');
 
@@ -222,7 +222,7 @@ describe('Echo Atom - Reactivity', () => {
     });
 
     // Reorder in place (e.g. move first to last).
-    Obj.change(obj, (obj) => {
+    Obj.update(obj, (obj) => {
       arrayMove(obj.stringArray!, 0, 2);
     });
 

package/src/ref-atom.test.ts

@@ -5,11 +5,13 @@
 import * as Registry from '@effect-atom/atom/Registry';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Obj, Ref } from '@dxos/echo';
-import { TestSchema } from '@dxos/echo/testing';
+import { Filter, Obj, Ref } from '@dxos/echo';
 import { type EchoDatabase } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
+import { TestSchema } from '@dxos/echo/testing';
+import { PublicKey } from '@dxos/keys';
 
+import * as AtomObj from './atom';
 import * as AtomRef from './ref-atom';
 
 describe('AtomRef - Basic Functionality', () => {
@@ -29,7 +31,7 @@ describe('AtomRef - Basic Functionality', () => {
   });
 
   test('AtomRef.make returns target when ref is loaded', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -44,7 +46,7 @@ describe('AtomRef - Basic Functionality', () => {
   });
 
   test('AtomRef.make does not subscribe to target changes (use AtomObj for reactive snapshots)', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -60,13 +62,45 @@ describe('AtomRef - Basic Functionality', () => {
     expect(updateCount).toBe(1);
 
     // Mutate target - ref atom does NOT react to this.
-    Obj.change(targetObj, (o) => {
-      o.name = 'Updated';
+    Obj.update(targetObj, (targetObj) => {
+      targetObj.name = 'Updated';
     });
 
     // Update count should still be 1 - ref atom doesn't subscribe to target changes.
     expect(updateCount).toBe(1);
   });
+
+  // Sibling client (sharing services) creates a brand-new ref target. The atom
+  // must update once the target's document propagates and resolves.
+  test('atom resolves target created by sibling client', async () => {
+    const [spaceKey] = PublicKey.randomSequence();
+    await using peer = await testBuilder.createPeer({
+      types: [TestSchema.Person, TestSchema.Container],
+    });
+    await using db1 = await peer.createDatabase(spaceKey);
+    const parent1 = db1.add(Obj.make(TestSchema.Container, { objects: [] }));
+    await db1.flush();
+
+    await using client2 = await peer.createClient();
+    await using db2 = await peer.openDatabase(spaceKey, db1.rootUrl!, { client: client2 });
+    const [parent2] = await db2.query(Filter.id(parent1.id)).run();
+
+    const newPerson = db2.add(
+      Obj.make(TestSchema.Person, { name: 'Alice', username: 'alice', email: 'alice@example.com' }),
+    );
+    Obj.update(parent2, (parent2) => {
+      parent2.objects = [...(parent2.objects ?? []), Ref.make(newPerson)];
+    });
+    await db2.flush();
+
+    await expect.poll(() => (parent1.objects ?? []).length).toBeGreaterThan(0);
+    const atom = AtomObj.make(parent1.objects![0]);
+
+    let lastValue: any;
+    registry.subscribe(atom, (value) => (lastValue = value), { immediate: true });
+
+    await expect.poll(() => lastValue?.name).toBe('Alice');
+  });
 });
 
 describe('AtomRef - Referential Equality', () => {
@@ -86,7 +120,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('AtomRef.make returns same atom instance for same ref', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -102,7 +136,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('AtomRef.make returns different atom instances for different refs', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj1 = Obj.make(TestSchema.Person, {
       name: 'Target1',
@@ -129,7 +163,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('AtomRef.make returns same atom for refs created separately to same target', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);
@@ -154,7 +188,7 @@ describe('AtomRef - Referential Equality', () => {
   });
 
   test('cached ref atoms return same instance after multiple retrievals', async () => {
-    await db.graph.schemaRegistry.register([TestSchema.Person]);
+    db.graph.registry.add([TestSchema.Person]);
 
     const targetObj = Obj.make(TestSchema.Person, { name: 'Target', username: 'target', email: 'target@example.com' });
     db.add(targetObj);