@dxos/echo 0.9.0 → 0.9.1-staging.ee54ba693a

package/src/internal/Obj/atoms.ts

@@ -14,10 +14,13 @@ import type * as Entity from '../../Entity';
 import type * as Obj from '../../Obj';
 import type * as Ref from '../../Ref';
 import type * as Relation from '../../Relation';
+import { getLabel } from '../Annotation';
+import { snapshotForComparison } from '../common/atom-snapshot';
 import { subscribe } from '../common/proxy/reactive';
-import { isEntity, getDatabase } from '../Entity';
+import { getDatabase, isEntity } from '../Entity';
 import { RefTypeId } from '../Ref/ref';
 import { loadRefTarget } from '../Ref/utils';
+import { isDeleted } from './deleted';
 import { getSnapshot } from './snapshot';
 
 const isRef = (obj: unknown): obj is Ref.Ref<any> =>
@@ -62,8 +65,9 @@ const refFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Ato
     const setupTargetSubscription = (target: T): Obj.Snapshot<T> => {
       unsubscribeTarget?.();
       unsubscribeTarget = subscribe(target, () => {
+        // Deleted objects resolve to undefined so callers don't need to inspect isDeleted.
         // getSnapshot adds SnapshotKindId brand at runtime; cast bridges static types.
-        get.setSelf(getSnapshot(target) as unknown as Obj.Snapshot<T>);
+        get.setSelf(isDeleted(target) ? undefined : (getSnapshot(target) as unknown as Obj.Snapshot<T>));
       });
       return getSnapshot(target) as unknown as Obj.Snapshot<T>;
     };
@@ -76,19 +80,6 @@ const refFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>): Atom.Ato
   }).pipe(Atom.keepAlive);
 });
 
-/**
- * Snapshot a value to create a new reference for comparison and React dependency tracking.
- */
-const snapshotForComparison = <V>(value: V): V => {
-  if (Array.isArray(value)) {
-    return [...value] as V;
-  }
-  if (value !== null && typeof value === 'object') {
-    return { ...value } as V;
-  }
-  return value;
-};
-
 /**
  * Atom family for ECHO object properties.
  * Uses nested families: outer keyed by object, inner keyed by property key.
@@ -149,6 +140,20 @@ const refWithReactiveFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T
   );
 });
 
+/**
+ * Atom family for a property of a ref's target object.
+ * Resolves the ref (reactively) then projects the property atom, so it fires when the ref resolves or when
+ * that property changes. Yields `undefined` while the target is unresolved.
+ */
+const refPropertyFamily = Atom.family(<T extends Obj.Unknown>(ref: Ref.Ref<T>) =>
+  Atom.family(<K extends keyof T>(key: K): Atom.Atom<T[K] | undefined> => {
+    return Atom.make<T[K] | undefined>((get) => {
+      const target = get(refWithReactiveFamily(ref));
+      return target ? get(propertyFamily(target)(key)) : undefined;
+    }).pipe(Atom.keepAlive);
+  }),
+);
+
 /**
  * Atom family for any ECHO entity (obj or relation) — returns a snapshot.
  */
@@ -200,10 +205,19 @@ export const makeAtom: {
 };
 
 /**
- * Create a read-only atom for a specific property of a reactive object.
- * Only fires updates when the property value actually changes.
+ * Create a read-only atom for a specific property of a reactive object, or of a ref's target.
+ * Only fires updates when the property value actually changes. Given a ref, the atom resolves the target
+ * first and yields `undefined` until it loads.
  */
-export const makeProperty = <T extends Obj.Unknown, K extends keyof T>(obj: T, key: K): Atom.Atom<T[K]> => {
+export const makeProperty: {
+  <T extends Obj.Unknown, K extends keyof T>(obj: T, key: K): Atom.Atom<T[K]>;
+  <T extends Obj.Unknown, K extends keyof T>(ref: Ref.Ref<T>, key: K): Atom.Atom<T[K] | undefined>;
+} = (objOrRef: Obj.Unknown | Ref.Ref<any>, key: any): Atom.Atom<any> => {
+  if (isRef(objOrRef)) {
+    return refPropertyFamily(objOrRef as Ref.Ref<any>)(key);
+  }
+
+  const obj = objOrRef as Obj.Unknown;
   assertArgument(isEntity(obj), 'obj', 'Object must be a reactive object');
   return propertyFamily(obj)(key);
 };
@@ -242,3 +256,33 @@ export const makeRelation = <T extends Relation.Unknown>(relation: T): Atom.Atom
   assertArgument(isEntity(relation), 'relation', 'Must be a reactive ECHO relation');
   return relationFamily(relation);
 };
+
+/**
+ * Atom family for an entity's label string.
+ * Fires only when the computed label actually changes, not on every entity mutation.
+ */
+const labelAtomFamily = Atom.family(<T extends Entity.Unknown>(entity: T): Atom.Atom<string | undefined> => {
+  return Atom.make<string | undefined>((get) => {
+    let previous = getLabel(entity);
+
+    const unsubscribe = subscribe(entity, () => {
+      const next = getLabel(entity);
+      if (next !== previous) {
+        previous = next;
+        get.setSelf(next);
+      }
+    });
+
+    get.addFinalizer(() => unsubscribe());
+    return previous;
+  }).pipe(Atom.keepAlive);
+});
+
+/**
+ * Create a read-only atom for the label of a reactive ECHO entity.
+ * Re-evaluates on entity mutation; only propagates when the label string changes.
+ */
+export const makeLabelAtom = <T extends Entity.Unknown>(entity: T): Atom.Atom<string | undefined> => {
+  assertArgument(isEntity(entity), 'entity', 'Must be a reactive ECHO entity');
+  return labelAtomFamily(entity);
+};

package/src/internal/Obj/clone.ts

@@ -3,20 +3,42 @@
 //
 
 import { invariant } from '@dxos/invariant';
-import { deepMapValues } from '@dxos/util';
+import { assumeType, deepMapValues } from '@dxos/util';
 
 import type * as Obj from '../../Obj';
 import { makeObject } from '../common/proxy';
-import { getSchema, getStaticTypeSchema, getType } from '../common/types';
+import { ParentId, getSchema, getStaticTypeSchema, getType } from '../common/types';
 import { getMeta } from '../common/types/meta';
+import { type InternalObjectProps } from '../Entity/model';
 import { Ref } from '../Ref';
 
 /**
  * Clones an object or relation.
- * This does not clone referenced objects, only the properties in the object.
+ * By default this does not clone referenced objects, only the properties in the object; pass `opts.deep`
+ * to recurse into refs (see {@link Obj.CloneOptions}).
  * @returns A new object with the same schema and properties.
  */
-export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T => {
+export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T =>
+  cloneInner(obj, opts, obj, new Map(), new Set());
+
+/**
+ * Recursive clone worker threaded with two cycle-guard structures:
+ * - `cache`: id → already-finished clone; reused when the same object appears more than once in a DAG.
+ * - `inProgress`: ids of objects whose clone is currently being computed; a ref back into this set means
+ *   a true cycle — the original ref is kept rather than recursing forever.
+ */
+const cloneInner = <T extends Obj.Any>(
+  obj: T,
+  opts: Obj.CloneOptions | undefined,
+  root: Obj.Any,
+  cache: Map<string, Obj.Any>,
+  inProgress: Set<string>,
+): T => {
+  if (cache.has(obj.id)) {
+    return cache.get(obj.id) as T;
+  }
+  inProgress.add(obj.id);
+
   const { id, ...data } = obj;
   // Prefer cloning through the type entity so the cloned instance preserves
   // `Obj.getType` identity. Falls back to the raw schema for older instances
@@ -24,30 +46,49 @@ export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T =>
   const typeEntity = getType(obj);
   const schema = typeEntity != null ? getStaticTypeSchema(typeEntity) : getSchema(obj);
   invariant(schema != null, 'Object should have a type or schema');
-  const props: any = deepMapValues(data, (value, recurse) => {
+
+  const mapRef = (value: unknown, recurse: (value: unknown) => unknown): unknown => {
     if (Ref.isRef(value)) {
-      if (opts?.deep) {
-        // TODO(dmaretskyi): Will break on circular references.
-        return Ref.make(clone(value.target!, opts));
+      const target = value.target;
+      // A ref back to an in-progress object means a cycle — keep the original ref to break it.
+      if (
+        target != null &&
+        !inProgress.has(target.id) &&
+        (opts?.deep === 'all' || (opts?.deep === 'parent' && isChildOf(target, root)))
+      ) {
+        return Ref.make(cloneInner(target, opts, root, cache, inProgress));
       }
       return value;
     }
     return recurse(value);
-  });
+  };
 
+  const props: any = deepMapValues(data, mapRef);
   if (opts?.retainId) {
     props.id = id;
   }
-  const meta = deepMapValues(getMeta(obj), (value, recurse) => {
-    if (Ref.isRef(value)) {
-      if (opts?.deep) {
-        // TODO(dmaretskyi): Will break on circular references.
-        return Ref.make(clone(value.target!, opts));
-      }
-      return value;
-    }
-    return recurse(value);
-  });
+  const meta = deepMapValues(getMeta(obj), mapRef);
+  const result = makeObject(schema, props, meta, typeEntity as object | undefined);
+
+  inProgress.delete(obj.id);
+  cache.set(obj.id, result);
+  return result;
+};
 
-  return makeObject(schema, props, meta, typeEntity as object | undefined);
+/**
+ * Whether `entity`'s parent chain reaches `root` — i.e. it is an owned descendant that cascade-deletes with
+ * the root. Walks the `ParentId` back-links (a finite tree); guarded against cycles defensively.
+ */
+const isChildOf = (entity: unknown, root: Obj.Any): boolean => {
+  const seen = new Set<InternalObjectProps>();
+  assumeType<InternalObjectProps>(entity);
+  let parent = entity[ParentId];
+  while (parent != null && !seen.has(parent)) {
+    if (parent.id === root.id) {
+      return true;
+    }
+    seen.add(parent);
+    parent = parent[ParentId];
+  }
+  return false;
 };

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

@@ -54,13 +54,13 @@ describe('create (static version)', () => {
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
-      id: contact.id,
+      'id': contact.id,
       '@type': DXN.make(Type.getTypename(TestSchema.Person), Type.getVersion(TestSchema.Person)),
       '@meta': {
         keys: [],
       },
-      name: 'Bot',
-      email: 'bot@example.com',
+      'name': 'Bot',
+      'email': 'bot@example.com',
     });
     expect(objectToJSON(contact)).toStrictEqual(json);
   });

package/src/internal/Obj/create-object.ts

@@ -55,10 +55,9 @@ export type CreateObjectProps<T> = (T extends { id: string }
  *
  * @example
  * ```ts
- * const Contact = Schema.Struct({
- *   name: Schema.String,
- *   email: Schema.String,
- * }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')))
+ * class Contact extends Type.makeObject<Contact>(DXN.make('com.example.type.person', '0.1.0'))(
+ *   Schema.Struct({ name: Schema.String, email: Schema.String }),
+ * ) {}
  *
  * const contact = createObject(Contact, {
  *   name: "John",

package/src/internal/Obj/inspect.ts

@@ -7,7 +7,7 @@ import type { InspectOptionsStylized, inspect as inspectFn } from 'node:util';
 import { type CustomInspectFunction, inspectCustom } from '@dxos/debug';
 
 import { getTypeURI } from '../Annotation';
-import { ATTR_TYPE, type AnyEntity } from '../common/types';
+import { type AnyEntity, ATTR_TYPE } from '../common/types';
 import { ATTR_META } from '../common/types/meta';
 import { MetaId } from '../common/types/model-symbols';
 

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

@@ -10,7 +10,7 @@ import { DXN, EID } from '@dxos/keys';
 import * as Obj from '../../Obj';
 import { TestSchema } from '../../testing';
 import * as Type from '../../Type';
-import { getTypeURI, getTypename } from '../Annotation';
+import { getTypename, getTypeURI } from '../Annotation';
 import { getMetaChecked } from '../common/api';
 import { ATTR_TYPE, EntityKind, KindId, TypeId, getSchema } from '../common/types';
 import { MetaId } from '../common/types/model-symbols';
@@ -160,10 +160,12 @@ describe('Object JSON serializer', () => {
   });
 
   describe('Uint8Array', () => {
-    const Blob = Schema.Struct({
-      name: Schema.String,
-      bytes: Schema.Uint8ArrayFromSelf,
-    }).pipe(Type.makeObject(DXN.make('com.example.type.blob', '0.1.0')));
+    const Blob = Type.makeObject(DXN.make('com.example.type.blob', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        bytes: Schema.Uint8ArrayFromSelf,
+      }),
+    );
     type Blob = Type.InstanceType<typeof Blob>;
 
     test('round-trips Uint8Array field through JSON with schema', async ({ expect }) => {

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

@@ -15,9 +15,9 @@ import type * as Obj from '../../Obj';
 import { getTypeAnnotation, getTypeURI, setTypename } from '../Annotation';
 import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../common/proxy';
 import {
+  type AnyEntity,
   ATTR_PARENT,
   ATTR_TYPE,
-  type AnyEntity,
   EntityKind,
   KindId,
   ParentId,
@@ -129,8 +129,8 @@ export const objectFromJSON = async (
     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;
+    const source = (await refResolver?.resolveLegacy(sourceDxn)) as AnyEntity | undefined;
+    const target = (await refResolver?.resolveLegacy(targetDxn)) as AnyEntity | undefined;
 
     defineHiddenProperty(obj, KindId, EntityKind.Relation);
     defineHiddenProperty(obj, RelationSourceDXNId, sourceDxn);
@@ -161,7 +161,7 @@ export const objectFromJSON = async (
 
   if (jsonData[ATTR_PARENT]) {
     const parentDxn = jsonData[ATTR_PARENT];
-    const resolvedParent = (await refResolver?.resolve(parentDxn)) as Obj.Unknown | undefined;
+    const resolvedParent = (await refResolver?.resolveLegacy(parentDxn)) as Obj.Unknown | undefined;
     defineHiddenProperty(obj, ParentId, resolvedParent);
   } else if (parent) {
     defineHiddenProperty(obj, ParentId, parent);

package/src/internal/Obj/schema-validator.test.ts

@@ -129,6 +129,19 @@ describe('schema-validator', () => {
         valueToAssign: { any: 'value' },
       });
     });
+
+    test('walking into an Unknown-typed value does not throw', ({ expect }) => {
+      // Mirrors the annotation Dictionary (Record<string, Unknown>): nested keys/indices under an
+      // Unknown slot are all valid, so the validator must not reject while walking them.
+      const schema = Schema.Struct({ dict: Schema.Record({ key: Schema.String, value: Schema.Unknown }) });
+      for (const path of [
+        ['dict', 'someType'],
+        ['dict', 'someType', 'nested'],
+        ['dict', 'someType', '0'],
+      ]) {
+        SchemaValidator.getPropertySchema(schema, path);
+      }
+    });
     test('index signatures', () => {
       for (const value of [42, '42']) {
         validateValueToAssign({
@@ -179,4 +192,44 @@ describe('schema-validator', () => {
       }
     });
   });
+
+  describe('assertExactProperties', () => {
+    test('rejects extra properties on a closed struct', () => {
+      const Person = Schema.Struct({ name: Schema.String });
+      expect(() => SchemaValidator.assertExactProperties(Person, { name: 'Alice', extra: true })).to.throw(
+        /Unknown property: extra/,
+      );
+    });
+
+    test('allows extra properties when the schema has an index signature', () => {
+      const Expando = Schema.Struct({}, { key: Schema.String, value: Schema.Any });
+      expect(() => SchemaValidator.assertExactProperties(Expando, { custom: 'value' })).not.to.throw();
+    });
+
+    test('rejects extra nested properties', () => {
+      const schema = Schema.Struct({
+        nested: Schema.Struct({ field: Schema.Number }),
+      });
+      expect(() => SchemaValidator.assertExactProperties(schema, { nested: { field: 1, extra: true } })).to.throw(
+        /Unknown property: nested.extra/,
+      );
+    });
+
+    test('resolves nested discriminated union using target property values', () => {
+      const spec = Schema.Union(
+        Schema.Struct({ kind: Schema.Literal('feed'), feed: Schema.optional(Schema.String) }),
+        Schema.Struct({ kind: Schema.Literal('timer'), cron: Schema.String }),
+      );
+      const schema = Schema.Struct({ spec });
+      const target = { spec: { kind: 'feed' as const, feed: 'echo:/feed', extra: true } };
+      expect(() => SchemaValidator.assertExactProperties(schema, target, (path) => getDeep(target, path))).to.throw(
+        /Unknown property: spec.extra/,
+      );
+      expect(() =>
+        SchemaValidator.assertExactProperties(schema, { spec: { kind: 'feed' as const } }, (path) =>
+          getDeep({ spec: { kind: 'feed' as const } }, path),
+        ),
+      ).not.to.throw();
+    });
+  });
 });

package/src/internal/Obj/set-value.test.ts

@@ -59,10 +59,12 @@ describe('Obj.setValue', () => {
       value: Schema.optional(Schema.Number),
     });
 
-    const Container = Schema.Struct({
-      name: Schema.String,
-      items: Schema.optional(Schema.Array(Item)),
-    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
+    const Container = Type.makeObject(DXN.make('com.test.type.container', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        items: Schema.optional(Schema.Array(Item)),
+      }),
+    );
 
     const container = Obj.make(Container, { name: 'box' });
 
@@ -146,9 +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.makeObject(DXN.make('com.test.type.matrix', '0.1.0')));
+    const Matrix = Type.makeObject(DXN.make('com.test.type.matrix', '0.1.0'))(
+      Schema.Struct({
+        values: Schema.optional(Schema.Array(Schema.Array(Schema.Number))),
+      }),
+    );
 
     const matrix = Obj.make(Matrix, {});
 
@@ -194,10 +198,12 @@ describe('Obj.setValue', () => {
       value: Schema.optional(Schema.Number),
     });
 
-    const Container = Schema.Struct({
-      name: Schema.String,
-      items: Schema.optional(Schema.Array(Item)),
-    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
+    const Container = Type.makeObject(DXN.make('com.test.type.container', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        items: Schema.optional(Schema.Array(Item)),
+      }),
+    );
 
     const container = Obj.make(Container, { name: 'box' });
 
@@ -216,10 +222,12 @@ describe('Obj.setValue', () => {
       completed: Schema.optional(Schema.Boolean),
     });
 
-    const TodoList = Schema.Struct({
-      name: Schema.String,
-      tasks: Schema.optional(Schema.Array(Task)),
-    }).pipe(Type.makeObject(DXN.make('com.test.type.todoList', '0.1.0')));
+    const TodoList = Type.makeObject(DXN.make('com.test.type.todoList', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        tasks: Schema.optional(Schema.Array(Task)),
+      }),
+    );
 
     const todoList = Obj.make(TodoList, { name: 'My Tasks' });
 
@@ -240,10 +248,12 @@ describe('Obj.setValue', () => {
       label: Schema.optional(Schema.String), // Optional - should not be initialized
     });
 
-    const Container = Schema.Struct({
-      name: Schema.String,
-      items: Schema.optional(Schema.Array(Item)),
-    }).pipe(Type.makeObject(DXN.make('com.test.type.container', '0.1.0')));
+    const Container = Type.makeObject(DXN.make('com.test.type.container', '0.1.0'))(
+      Schema.Struct({
+        name: Schema.String,
+        items: Schema.optional(Schema.Array(Item)),
+      }),
+    );
 
     const container = Obj.make(Container, { name: 'box' });
 

package/src/internal/Query/index.ts

@@ -3,3 +3,4 @@
 //
 
 export * from './pretty';
+export * from './query-result-effect';

package/src/internal/Query/query-result-effect.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Effectable from 'effect/Effectable';
+import * as Option from 'effect/Option';
+
+import { EffectEx } from '@dxos/effect';
+
+import type * as QueryResult from '../../QueryResult';
+
+/**
+ * Wraps an effect that produces a {@link QueryResult.QueryResult} into a
+ * {@link QueryResult.QueryResultEffect}, exposing `.run` and `.first` shorthands that execute the
+ * query once. Shared by `Database.query` and `Feed.query` so both surfaces chain identically.
+ */
+export const makeQueryResultEffect = <T, E, R>(
+  eff: Effect.Effect<QueryResult.QueryResult<T>, E, R>,
+): QueryResult.QueryResultEffect<T, E, R> => {
+  return {
+    run: Effect.flatMap(eff, (result) => EffectEx.promiseWithCauseCapture(() => result.run())),
+    first: Effect.flatMap(eff, (result) =>
+      EffectEx.promiseWithCauseCapture(async () => Option.fromNullable(await result.firstOrUndefined())),
+    ),
+
+    // Effect internals: the result is itself an Effect, so it carries the commit prototype.
+    ...Effectable.CommitPrototype,
+    commit() {
+      return eff;
+    },
+    // Cast required: Effect's commit protocol is supplied at runtime via `CommitPrototype` and
+    // cannot be expressed by the object literal's static type.
+  } as any;
+};

package/src/internal/Ref/atoms.ts

@@ -4,17 +4,37 @@
 
 import * as Atom from '@effect-atom/atom/Atom';
 
+import { subscribe } from '../common/proxy/reactive';
+import { ObjectDeletedId } from '../common/types/model-symbols';
 import type { Ref } from './ref';
 import { loadRefTarget } from './utils';
 
 /**
  * Atom family for ECHO refs.
  * Uses ref reference as key — same ref returns same atom.
- * This atom only updates once when the ref loads — it does not subscribe to target object changes.
- * Use `Obj.atom(ref)` if you need reactive snapshots of ECHO objects via a ref.
+ * Subscribes to target object changes and resolves to undefined when the target is deleted.
  */
 export const refSimpleFamily = Atom.family(<T>(ref: Ref<T>): Atom.Atom<T | undefined> => {
   return Atom.make<T | undefined>((get) => {
-    return loadRefTarget(ref, get, (target) => target);
+    let unsubscribeTarget: (() => void) | undefined;
+
+    const setupSubscription = (target: T): T | undefined => {
+      // Release any previous subscription before re-subscribing (loadRefTarget may call this more than once).
+      // T has no ECHO-proxy constraint at this generic level; `subscribe` and ObjectDeletedId
+      // both require the internal proxy shape that cannot be expressed statically here.
+      unsubscribeTarget?.();
+      unsubscribeTarget = subscribe(target as any, () => {
+        const deleted = !!(target as any)[ObjectDeletedId];
+        get.setSelf(deleted ? undefined : target);
+      });
+      const deleted = !!(target as any)[ObjectDeletedId];
+      return deleted ? undefined : target;
+    };
+
+    get.addFinalizer(() => {
+      unsubscribeTarget?.();
+    });
+
+    return loadRefTarget(ref, get, setupSubscription);
   });
 });

package/src/internal/Ref/index.ts

@@ -4,3 +4,4 @@
 
 export * from './ref';
 export * from './ref-array';
+export * from './strong-deps';

package/src/internal/Ref/ref.test.ts

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { EID, EntityId, DXN } from '@dxos/keys';
+import { DXN, EID, EntityId } from '@dxos/keys';
 
 import * as Type from '../../Type';
 import { EchoObjectSchema, getObjectEchoUri } from '../Entity';
@@ -45,16 +45,16 @@ describe('Ref', () => {
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
-      id: contact.id,
+      'id': contact.id,
       '@type': `dxn:${Type.getTypename(Contact)}:${Type.getVersion(Contact)}`,
       '@meta': {
         keys: [],
       },
-      name: 'John Doe',
-      tasks: [
+      'name': 'John Doe',
+      'tasks': [
         {
           '/': getObjectEchoUri(task)!.toString(),
-          target: JSON.parse(JSON.stringify(task)),
+          'target': JSON.parse(JSON.stringify(task)),
         },
       ],
     });
@@ -66,13 +66,13 @@ describe('Ref', () => {
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
-      id: contact.id,
+      'id': contact.id,
       '@type': `dxn:${Type.getTypename(Contact)}:${Type.getVersion(Contact)}`,
       '@meta': {
         keys: [],
       },
-      name: 'John Doe',
-      tasks: [{ '/': getObjectEchoUri(task)!.toString() }],
+      'name': 'John Doe',
+      'tasks': [{ '/': getObjectEchoUri(task)!.toString() }],
     });
   });