@dxos/echo-atom 0.8.4-main.bc674ce → 0.8.4-main.c351d160a8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo-atom",
-  "version": "0.8.4-main.bc674ce",
+  "version": "0.8.4-main.c351d160a8",
   "description": "Effect Atom wrappers for ECHO objects with explicit subscriptions.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -16,8 +16,7 @@
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -29,17 +28,19 @@
     "src"
   ],
   "dependencies": {
-    "@effect-atom/atom": "^0.4.13",
-    "lodash.isequal": "^4.5.0",
-    "@dxos/echo": "0.8.4-main.bc674ce",
-    "@dxos/echo-db": "0.8.4-main.bc674ce",
-    "@dxos/util": "0.8.4-main.bc674ce",
-    "@dxos/invariant": "0.8.4-main.bc674ce"
+    "@effect-atom/atom": "^0.5.1",
+    "@dxos/echo": "0.8.4-main.c351d160a8",
+    "@dxos/echo-db": "0.8.4-main.c351d160a8",
+    "@dxos/invariant": "0.8.4-main.c351d160a8",
+    "@dxos/util": "0.8.4-main.c351d160a8"
   },
   "devDependencies": {
-    "@types/lodash.isequal": "^4.5.0",
-    "@dxos/random": "0.8.4-main.bc674ce",
-    "@dxos/test-utils": "0.8.4-main.bc674ce"
+    "effect": "3.19.16",
+    "@dxos/random": "0.8.4-main.c351d160a8",
+    "@dxos/test-utils": "0.8.4-main.c351d160a8"
+  },
+  "peerDependencies": {
+    "effect": "3.19.16"
   },
   "publishConfig": {
     "access": "public"

package/src/atom.test.ts

@@ -3,11 +3,12 @@
 //
 
 import * as Registry from '@effect-atom/atom/Registry';
-import { describe, expect, test } from 'vitest';
+import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
-import { Obj } from '@dxos/echo';
+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 * as AtomObj from './atom';
 
@@ -283,4 +284,115 @@ describe('Echo Atom - Referential Equality', () => {
     expect(updateCount).toBe(2);
     expect(registry.get(atom1)).toBe('Updated');
   });
+
+  test('AtomObj.make returns same atom instance for different ref instances with same DXN', ({ expect }) => {
+    const org = createObject(Obj.make(TestSchema.Organization, { name: 'DXOS' }));
+    const person = createObject(
+      Obj.make(TestSchema.Person, {
+        name: 'Test',
+        username: 'test',
+        email: 'test@example.com',
+        employer: Ref.make(org),
+      }),
+    );
+
+    // Each property access returns a new Ref instance from the ECHO proxy.
+    const ref1 = person.employer!;
+    const ref2 = person.employer!;
+    expect(ref1).not.toBe(ref2);
+
+    // Despite being different Ref instances, they should resolve to the same atom.
+    const atom1 = AtomObj.make(ref1);
+    const atom2 = AtomObj.make(ref2);
+    expect(atom1).toBe(atom2);
+  });
+});
+
+describe('AtomObj.makeWithReactive', () => {
+  test('returns object for direct obj input', () => {
+    const obj = createObject(
+      Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
+    );
+
+    const registry = Registry.make();
+    const atom = AtomObj.makeWithReactive(obj);
+    const result = registry.get(atom);
+
+    expect(result).toBe(obj);
+    expect(result?.name).toBe('Test');
+  });
+
+  test('returns same atom for same object', () => {
+    const obj = createObject(
+      Obj.make(TestSchema.Person, { name: 'Test', username: 'test', email: 'test@example.com' }),
+    );
+
+    const atom1 = AtomObj.makeWithReactive(obj);
+    const atom2 = AtomObj.makeWithReactive(obj);
+
+    expect(atom1).toBe(atom2);
+  });
+
+  describe('with ref input', () => {
+    let testBuilder: InstanceType<typeof EchoTestBuilder>;
+
+    beforeEach(async () => {
+      testBuilder = await new EchoTestBuilder().open();
+    });
+
+    afterEach(async () => {
+      await testBuilder.close();
+    });
+
+    test('returns resolved object for ref', async ({ expect }) => {
+      const { db } = await testBuilder.createDatabase({
+        types: [TestSchema.Person, TestSchema.Task],
+      });
+      const task = db.add(Obj.make(TestSchema.Task, { title: 'Task 1' }));
+      const person = db.add(
+        Obj.make(TestSchema.Person, {
+          name: 'Test',
+          username: 'test',
+          email: 'test@example.com',
+          tasks: [Ref.make(task)],
+        }),
+      );
+      await db.flush();
+
+      const ref = person.tasks![0];
+      const registry = Registry.make();
+      const atom = AtomObj.makeWithReactive(ref);
+      const result = registry.get(atom);
+
+      expect(result).toBe(task);
+      expect(result?.title).toBe('Task 1');
+    });
+
+    test('returns undefined when ref target was removed', async ({ expect }) => {
+      const { db } = await testBuilder.createDatabase({
+        types: [TestSchema.Person, TestSchema.Task],
+      });
+      const task = db.add(Obj.make(TestSchema.Task, { title: 'Task 1' }));
+      const person = db.add(
+        Obj.make(TestSchema.Person, {
+          name: 'Test',
+          username: 'test',
+          email: 'test@example.com',
+          tasks: [Ref.make(task)],
+        }),
+      );
+      await db.flush();
+
+      const ref = person.tasks![0];
+      const registry = Registry.make();
+      const atom = AtomObj.makeWithReactive(ref);
+
+      expect(registry.get(atom)).toBe(task);
+
+      db.remove(task);
+      await db.flush();
+
+      expect(registry.get(atom)).toBeUndefined();
+    });
+  });
 });

package/src/atom.ts

@@ -3,9 +3,12 @@
 //
 
 import * as Atom from '@effect-atom/atom/Atom';
-import isEqual from 'lodash.isequal';
+import * as Result from '@effect-atom/atom/Result';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
 
-import { Obj, Ref } from '@dxos/echo';
+import { type Entity, Obj, Ref, Relation } from '@dxos/echo';
 import { assertArgument } from '@dxos/invariant';
 
 import { loadRefTarget } from './ref-utils';
@@ -23,13 +26,13 @@ const objectFamily = Atom.family(<T extends Obj.Unknown>(obj: T): Atom.Atom<Obj.
     get.addFinalizer(() => unsubscribe());
 
     return Obj.getSnapshot(obj);
-  });
+  }).pipe(Atom.keepAlive);
 });
 
 /**
- * Internal helper to create an atom from a Ref.
- * Handles async loading and subscribes to the target for reactive updates.
- * Uses Atom.family internally - same ref reference returns same atom instance.
+ * Atom family for ECHO refs.
+ * RefImpl implements Effect's Hash/Equal traits using DXN, so different Ref instances
+ * pointing to the same object resolve to the same atom.
  */
 const refFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Atom<Obj.Snapshot<T> | undefined> => {
   return Atom.make<Obj.Snapshot<T> | undefined>((get) => {
@@ -43,10 +46,12 @@ const refFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Ato
       return Obj.getSnapshot(target);
     };
 
-    get.addFinalizer(() => unsubscribeTarget?.());
+    get.addFinalizer(() => {
+      unsubscribeTarget?.();
+    });
 
     return loadRefTarget(ref, get, setupTargetSubscription);
-  });
+  }).pipe(Atom.keepAlive);
 });
 
 /**
@@ -78,7 +83,7 @@ const propertyFamily = Atom.family(<T extends Obj.Unknown>(obj: T) =>
 
       const unsubscribe = Obj.subscribe(obj, () => {
         const newValue = obj[key];
-        if (!isEqual(previousSnapshot, newValue)) {
+        if (previousSnapshot !== newValue) {
           previousSnapshot = snapshotForComparison(newValue);
           // Return a snapshot copy so React sees a new reference.
           get.setSelf(snapshotForComparison(newValue));
@@ -89,43 +94,46 @@ const propertyFamily = Atom.family(<T extends Obj.Unknown>(obj: T) =>
 
       // Return a snapshot copy so React sees a new reference.
       return snapshotForComparison(obj[key]);
-    });
+    }).pipe(Atom.keepAlive);
   }),
 );
 
 /**
- * Create a read-only atom for a reactive object or ref.
- * Works with Echo objects, plain reactive objects (from Obj.make), and Refs.
- * Returns immutable snapshots of the object data (branded with SnapshotKindId).
+ * Create a read-only atom for a single reactive object or ref.
+ * Returns {@link Obj.Snapshot} (immutable plain data), not the live reactive object.
+ * Use this when you need one object's data for display or React dependency tracking.
  * The atom updates automatically when the object is mutated.
  * For refs, automatically handles async loading.
- * Uses Atom.family internally - same object/ref reference returns same atom instance.
+ * Uses Atom.family internally - same object/ref returns same atom instance.
  *
  * @param objOrRef - The reactive object or ref to create an atom for, or undefined.
- * @returns An atom that returns the object snapshot. Returns undefined only for refs (async loading) or undefined input.
+ * @returns An atom that returns the object snapshot (plain data). Returns undefined only for refs (async loading) or undefined input.
  */
 export function make<T extends Obj.Unknown>(obj: T): Atom.Atom<Obj.Snapshot<T>>;
+export function make<T extends Relation.Unknown>(relation: T): Atom.Atom<Relation.Snapshot<T>>;
+export function make<T extends Entity.Unknown>(entity: T): Atom.Atom<Entity.Snapshot>;
 export function make<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Atom<Obj.Snapshot<T> | undefined>;
 export function make<T extends Obj.Unknown>(
   objOrRef: T | Ref.Ref<T> | undefined,
 ): Atom.Atom<Obj.Snapshot<T> | undefined>;
-export function make<T extends Obj.Unknown>(
+export function make<T extends Entity.Unknown>(
   objOrRef: T | Ref.Ref<T> | undefined,
-): Atom.Atom<Obj.Snapshot<T> | undefined> {
+): Atom.Atom<Entity.Snapshot | undefined> {
   if (objOrRef === undefined) {
-    return Atom.make<Obj.Snapshot<T> | undefined>(() => undefined);
+    return Atom.make<Entity.Snapshot | undefined>(() => undefined);
   }
 
   // Handle Ref inputs.
   if (Ref.isRef(objOrRef)) {
-    return refFamily(objOrRef as Ref.Ref<T>);
+    return refFamily(objOrRef as any);
   }
 
   // At this point, objOrRef is definitely T (not a Ref).
   const obj = objOrRef as T;
-  assertArgument(Obj.isObject(obj), 'obj', 'Object must be a reactive object');
+  assertArgument(Obj.isObject(obj) || Relation.isRelation(obj), 'obj', 'Object must be a reactive object');
 
-  return objectFamily(obj);
+  // TODO(dmaretskyi): Fix echo types during review.
+  return objectFamily(obj as any);
 }
 
 /**
@@ -153,6 +161,67 @@ 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);
 }
+
+/**
+ * Atom family for ECHO objects - returns the live object, not a snapshot.
+ * Same as objectFamily but returns T instead of Obj.Snapshot<T>.
+ */
+const objectWithReactiveFamily = Atom.family(<T extends Obj.Unknown>(obj: T): Atom.Atom<T> => {
+  return Atom.make<T>((get) => {
+    const unsubscribe = Obj.subscribe(obj, () => {
+      get.setSelf(obj);
+    });
+
+    get.addFinalizer(() => unsubscribe());
+
+    return obj;
+  }).pipe(Atom.keepAlive);
+});
+
+/**
+ * Atom family for ECHO refs - returns the live reactive object, not a snapshot.
+ * Resolves the ref via the database; returns undefined while loading or if unresolved.
+ */
+const refWithReactiveFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Atom<T | undefined> => {
+  const effect = (get: Atom.Context) =>
+    Effect.gen(function* () {
+      const snapshot = get(make(ref));
+      if (snapshot == null) return undefined;
+      const option = yield* Obj.getReactiveOption(snapshot);
+      return Option.getOrElse(option, () => undefined);
+    });
+
+  return Function.pipe(
+    Atom.make(effect),
+    Atom.map((result) => Result.getOrElse(result, () => undefined)),
+  );
+});
+
+/**
+ * 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).
+ *
+ * @param objOrRef - The reactive object or ref.
+ * @returns An atom that returns the live object. Returns undefined for refs (async loading) or undefined input.
+ */
+export function makeWithReactive<T extends Obj.Unknown>(obj: T): Atom.Atom<T>;
+export function makeWithReactive<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Atom<T | undefined>;
+export function makeWithReactive<T extends Obj.Unknown>(objOrRef: T | Ref.Ref<T> | undefined): Atom.Atom<T | undefined>;
+export function makeWithReactive<T extends Obj.Unknown>(
+  objOrRef: T | Ref.Ref<T> | undefined,
+): Atom.Atom<T | undefined> {
+  if (objOrRef === undefined) {
+    return Atom.make<T | undefined>(() => undefined);
+  }
+
+  if (Ref.isRef(objOrRef)) {
+    return refWithReactiveFamily(objOrRef as Ref.Ref<T>);
+  }
+
+  const obj = objOrRef as T;
+  assertArgument(Obj.isObject(obj), 'obj', 'Object must be a reactive object');
+  return objectWithReactiveFamily(obj);
+}

package/src/query-atom.test.ts

@@ -6,9 +6,11 @@ import * as Registry from '@effect-atom/atom/Registry';
 import * as Schema from 'effect/Schema';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
 
+import { sleep } from '@dxos/async';
 import { Obj, type QueryResult, Type } from '@dxos/echo';
+import { Filter, Query } from '@dxos/echo';
 import { TestSchema } from '@dxos/echo/testing';
-import { type EchoDatabase, Filter, Query } from '@dxos/echo-db';
+import { type EchoDatabase, RuntimeSchemaRegistry } from '@dxos/echo-db';
 import { EchoTestBuilder } from '@dxos/echo-db/testing';
 import { SpaceId } from '@dxos/keys';
 
@@ -22,7 +24,7 @@ const TestItem = Schema.Struct({
   value: Schema.Number,
 }).pipe(
   Type.object({
-    typename: 'example.com/type/TestItem',
+    typename: 'com.example.type.test-item',
     version: '0.1.0',
   }),
 );
@@ -47,7 +49,7 @@ describe('AtomQuery', () => {
   test('creates atom with initial results', async () => {
     db.add(Obj.make(TestItem, { name: 'Object 1', value: 100 }));
     db.add(Obj.make(TestItem, { name: 'Object 2', value: 100 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 100 })),
@@ -63,7 +65,7 @@ describe('AtomQuery', () => {
 
   test('registry.subscribe fires on QueryResult changes', async () => {
     db.add(Obj.make(TestItem, { name: 'Initial', value: 200 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 200 })),
@@ -86,7 +88,7 @@ describe('AtomQuery', () => {
 
     // Add a new object that matches the query.
     db.add(Obj.make(TestItem, { name: 'New Object', value: 200 }));
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
 
     // Subscription should have fired.
     expect(updateCount).toBeGreaterThan(0);
@@ -96,7 +98,7 @@ describe('AtomQuery', () => {
   test('registry.subscribe fires when objects are removed', async () => {
     const obj1 = db.add(Obj.make(TestItem, { name: 'Object 1', value: 300 }));
     db.add(Obj.make(TestItem, { name: 'Object 2', value: 300 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 300 })),
@@ -119,7 +121,7 @@ describe('AtomQuery', () => {
 
     // Remove an object.
     db.remove(obj1);
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
 
     // Subscription should have fired.
     expect(updateCount).toBeGreaterThan(0);
@@ -129,7 +131,7 @@ describe('AtomQuery', () => {
 
   test('unsubscribing from registry stops receiving updates', async () => {
     db.add(Obj.make(TestItem, { name: 'Initial', value: 400 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 400 })),
@@ -150,7 +152,7 @@ describe('AtomQuery', () => {
 
     // Add object and verify subscription fires.
     db.add(Obj.make(TestItem, { name: 'Object 2', value: 400 }));
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
     const countAfterFirstAdd = updateCount;
     expect(countAfterFirstAdd).toBeGreaterThan(0);
 
@@ -159,7 +161,7 @@ describe('AtomQuery', () => {
 
     // Add another object.
     db.add(Obj.make(TestItem, { name: 'Object 3', value: 400 }));
-    await db.flush({ indexes: true, updates: true });
+    await db.flush({ updates: true });
 
     // Update count should not have changed after unsubscribe.
     expect(updateCount).toBe(countAfterFirstAdd);
@@ -179,7 +181,7 @@ describe('AtomQuery', () => {
 
   test('multiple atoms from same query share underlying subscription', async () => {
     db.add(Obj.make(TestItem, { name: 'Object', value: 500 }));
-    await db.flush({ indexes: true });
+    await db.flush();
 
     const queryResult: QueryResult.QueryResult<TestItem> = db.query(
       Query.select(Filter.type(TestItem, { value: 500 })),
@@ -260,3 +262,127 @@ describe('AtomQuery with queues', () => {
     expect(results[0].name).toEqual('jane');
   });
 });
+
+const SchemaA = Schema.Struct({
+  name: Schema.String,
+}).pipe(
+  Type.object({
+    typename: 'com.example.type.a',
+    version: '0.1.0',
+  }),
+);
+
+const SchemaB = Schema.Struct({
+  value: Schema.Number,
+}).pipe(
+  Type.object({
+    typename: 'com.example.type.b',
+    version: '0.1.0',
+  }),
+);
+
+describe('AtomQuery.fromQuery with schema registry', () => {
+  let schemaRegistry: RuntimeSchemaRegistry;
+  let registry: Registry.Registry;
+
+  beforeEach(() => {
+    schemaRegistry = new RuntimeSchemaRegistry([]);
+    registry = Registry.make();
+  });
+
+  test('creates atom with initial results from schema query', async ({ expect }) => {
+    await schemaRegistry.register([SchemaA]);
+
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+    const results = registry.get(atom);
+
+    expect(results).toHaveLength(1);
+    expect(Type.getTypename(results[0])).toBe('com.example.type.a');
+  });
+
+  test('atom updates when new schemas are registered', async ({ expect }) => {
+    await schemaRegistry.register([SchemaA]);
+
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+
+    // Get initial results and subscribe.
+    const initialResults = registry.get(atom);
+    expect(initialResults).toHaveLength(1);
+
+    let updateCount = 0;
+    let latestResults: Type.AnyEntity[] = [];
+    registry.subscribe(atom, () => {
+      updateCount++;
+      latestResults = registry.get(atom);
+    });
+
+    // Allow reactive query to start (deferred via queueMicrotask).
+    await sleep(10);
+
+    // Register a new schema.
+    await schemaRegistry.register([SchemaB]);
+
+    expect(updateCount).toBeGreaterThan(0);
+    expect(latestResults).toHaveLength(2);
+    expect(latestResults.map(Type.getTypename).sort()).toEqual(['com.example.type.a', 'com.example.type.b']);
+  });
+
+  test('atom works with empty initial results', ({ expect }) => {
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+    const results = registry.get(atom);
+
+    expect(results).toHaveLength(0);
+  });
+
+  test('atom with filtered query only reflects matching schemas', async ({ expect }) => {
+    const queryResult = schemaRegistry.query({ typename: 'com.example.type.a' });
+    const atom = AtomQuery.fromQuery(queryResult);
+
+    // Get initial (empty) results and subscribe.
+    const initialResults = registry.get(atom);
+    expect(initialResults).toHaveLength(0);
+
+    let latestResults: Type.AnyEntity[] = [];
+    registry.subscribe(atom, () => {
+      latestResults = registry.get(atom);
+    });
+
+    await sleep(10);
+
+    // Register non-matching schema.
+    await schemaRegistry.register([SchemaB]);
+    // Results updated but still empty for this filter.
+    expect(latestResults).toHaveLength(0);
+
+    // Register matching schema.
+    await schemaRegistry.register([SchemaA]);
+    expect(latestResults).toHaveLength(1);
+    expect(Type.getTypename(latestResults[0])).toBe('com.example.type.a');
+  });
+
+  test('unsubscribing from atom stops updates', async ({ expect }) => {
+    const queryResult = schemaRegistry.query();
+    const atom = AtomQuery.fromQuery(queryResult);
+
+    registry.get(atom);
+
+    let updateCount = 0;
+    const unsubscribe = registry.subscribe(atom, () => {
+      updateCount++;
+    });
+
+    await sleep(10);
+
+    await schemaRegistry.register([SchemaA]);
+    const countAfterFirst = updateCount;
+    expect(countAfterFirst).toBeGreaterThan(0);
+
+    unsubscribe();
+
+    await schemaRegistry.register([SchemaB]);
+    expect(updateCount).toBe(countAfterFirst);
+  });
+});

package/src/query-atom.ts

@@ -8,7 +8,7 @@ import { DXN, Database, type Entity, type Filter, Query, type QueryResult } from
 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).
@@ -37,7 +32,7 @@ const queryableRegistry = new WeakDictionary<string, Database.Queryable>();
 // Key separator that won't appear in identifiers (DXN strings use colons).
 const KEY_SEPARATOR = '~';
 
-// Atom.family keyed by "identifier\0serializedAST".
+// Atom.family keyed by "identifier~serializedAST".
 const queryFamily = Atom.family((key: string) => {
   // Parse key outside Atom.make - runs once per key.
   const separatorIndex = key.indexOf(KEY_SEPARATOR);

package/src/reactivity.test.ts

@@ -8,6 +8,7 @@ import { describe, expect, test } from 'vitest';
 import { Obj } from '@dxos/echo';
 import { TestSchema } from '@dxos/echo/testing';
 import { createObject } from '@dxos/echo-db';
+import { arrayMove } from '@dxos/util';
 
 import * as AtomObj from './atom';
 
@@ -203,4 +204,30 @@ describe('Echo Atom - Reactivity', () => {
 
     unsubscribe();
   });
+
+  test('property atom for array property updates when array is reordered in place', () => {
+    // Verifies that makeProperty(obj, 'columns')-style atoms subscribe to in-place
+    // array mutations (e.g. arrayMove), so UI stays in sync after column reorder.
+    const obj = createObject(Obj.make(TestSchema.Example, { stringArray: ['a', 'b', 'c'] }));
+
+    const registry = Registry.make();
+    const atom = AtomObj.makeProperty(obj, 'stringArray');
+
+    const initial = registry.get(atom);
+    expect(initial).toEqual(['a', 'b', 'c']);
+
+    let updateCount = 0;
+    registry.subscribe(atom, () => {
+      updateCount++;
+    });
+
+    // Reorder in place (e.g. move first to last).
+    Obj.change(obj, (obj) => {
+      arrayMove(obj.stringArray!, 0, 2);
+    });
+
+    expect(updateCount).toBe(1);
+    const afterReorder = registry.get(atom);
+    expect(afterReorder).toEqual(['b', 'c', 'a']);
+  });
 });