@dxos/echo 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/internal/common/proxy/reactive.test.ts

@@ -0,0 +1,54 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import * as Obj from '../../../Obj';
+import { TestSchema } from '../../../testing';
+
+describe('Obj.subscribe', () => {
+  test('subscribes and fires for reactive proxies', () => {
+    const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+    let calls = 0;
+    const unsubscribe = Obj.subscribe(obj, () => {
+      calls++;
+    });
+
+    Obj.update(obj, (obj) => {
+      obj.name = 'Updated';
+    });
+    expect(calls).toBeGreaterThan(0);
+
+    unsubscribe();
+    const seen = calls;
+    Obj.update(obj, (obj) => {
+      obj.name = 'After unsubscribe';
+    });
+    expect(calls).toBe(seen);
+  });
+
+  // Regression: queue-stored typed objects (e.g. AiContext.Binding) and other Obj-shaped values
+  // satisfy `Obj.isObject` (KindId is set) but are not wrapped in a reactive Proxy. Earlier
+  // versions invariant'd inside `getProxyTarget` when an atom body did `Obj.subscribe(obj)` on
+  // such an input. The contract is "no-op for non-reactive inputs"; verify the function
+  // returns gracefully instead of throwing.
+  test('returns a no-op unsubscribe for non-proxy inputs', () => {
+    const queueShaped: any = {
+      id: '01KQ5NKXJWSKMRPVTVG2GHV8V3',
+      blueprints: { added: [], removed: [] },
+      objects: { added: [], removed: [] },
+    };
+    const unsubscribe = Obj.subscribe(queueShaped, () => {});
+    expect(typeof unsubscribe).toBe('function');
+    expect(() => unsubscribe()).not.toThrow();
+  });
+
+  test('returns a no-op unsubscribe for primitives, null, and undefined', () => {
+    for (const value of [null, undefined, 42, 'string', true]) {
+      const unsubscribe = Obj.subscribe(value as any, () => {});
+      expect(typeof unsubscribe).toBe('function');
+      expect(() => unsubscribe()).not.toThrow();
+    }
+  });
+});

package/src/internal/common/proxy/reactive.ts

@@ -3,8 +3,7 @@
 //
 
 import { type RefTypeId } from '../../Ref/ref';
-
-import { getProxyTarget } from './proxy-utils';
+import { getProxyTarget, isProxy } from './proxy-utils';
 import { ChangeId, EventId } from './symbols';
 
 /**
@@ -15,6 +14,15 @@ import { ChangeId, EventId } from './symbols';
  */
 // TODO(wittjosiah): Consider throwing if obj doesn't have EventId instead of returning no-op.
 export const subscribe = (obj: unknown, callback: () => void): (() => void) => {
+  // Guard against non-reactive inputs (queue-stored typed objects, snapshots, plain shapes
+  // with branded symbols) before `getProxyTarget`'s `ProxyHandlerSlot` invariant kicks in.
+  // `Obj.isObject` (KindId-based) is satisfied by these inputs, so callers like
+  // `Atom.family((obj) => Atom.make((get) => Obj.subscribe(obj, ...)))` legitimately reach
+  // here with a non-proxy. Falling back to a no-op preserves the documented contract that
+  // values without subscription support get a no-op unsubscribe.
+  if (!isProxy(obj)) {
+    return () => {};
+  }
   const target = getProxyTarget(obj as any);
   if (target && EventId in target) {
     return (target as any)[EventId].on(callback);
@@ -24,7 +32,7 @@ export const subscribe = (obj: unknown, callback: () => void): (() => void) => {
 
 /**
  * Deeply removes readonly modifiers from all properties of T.
- * Inside Obj.change, all properties are fully mutable regardless of schema definition.
+ * Inside Obj.update, all properties are fully mutable regardless of schema definition.
  * Ref types are preserved as-is since they are value-like objects that are replaced, not mutated.
  * Primitive types (including branded primitives) are preserved as-is.
  */

package/src/internal/common/proxy/typed-handler.test.ts

@@ -10,7 +10,6 @@ import { EchoObjectSchema } from '../../Entity';
 import { setValue } from '../../Obj';
 import { Ref } from '../../Ref';
 import { foreignKey, getMeta } from '../types';
-
 import { makeObject } from './make-object';
 import { change, subscribe } from './reactive';
 

package/src/internal/common/proxy/typed-handler.ts

@@ -2,10 +2,9 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type InspectOptionsStylized } from 'node:util';
-
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
+import { type InspectOptionsStylized } from 'node:util';
 
 import { Event } from '@dxos/async';
 import { inspectCustom } from '@dxos/debug';
@@ -13,7 +12,6 @@ import { invariant } from '@dxos/invariant';
 
 import { getSchemaDXN } from '../../Annotation';
 import { ObjectDeletedId, ParentId, SchemaId, TypeId } from '../types';
-
 import { executeChange, isInChangeContext, queueNotification } from './change-context';
 import { defineHiddenProperty } from './define-hidden-property';
 import { createPropertyDeleteError } from './errors';
@@ -228,7 +226,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
   set(target: ProxyTarget, prop: string | symbol, value: any, receiver: any): boolean {
     const echoRoot = getEchoRoot(target);
 
-    // Check readonly enforcement - mutations only allowed within Obj.change().
+    // Check readonly enforcement - mutations only allowed within Obj.update().
     // Skip check if the object is still being initialized (no ChangeId handler yet).
     // Also skip for non-initialized root objects (those without EventId).
     // Skip for symbol properties (internal infrastructure, not user data).
@@ -236,8 +234,8 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
     const isSymbolProp = typeof prop === 'symbol';
     if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
       throw new Error(
-        `Cannot modify object property "${String(prop)}" outside of Obj.change(). ` +
-          'Use Obj.change(obj, (mutableObj) => { mutableObj.property = value; }) instead.',
+        `Cannot modify object property "${String(prop)}" outside of Obj.update(). ` +
+          'Use Obj.update(obj, (mutableObj) => { mutableObj.property = value; }) instead.',
       );
     }
 
@@ -267,7 +265,7 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
   deleteProperty(target: ProxyTarget, property: string | symbol): boolean {
     const echoRoot = getEchoRoot(target);
 
-    // Check readonly enforcement - mutations only allowed within Obj.change().
+    // Check readonly enforcement - mutations only allowed within Obj.update().
     // Skip for symbol properties (internal infrastructure, not user data).
     const isInitialized = (echoRoot as any)[ChangeId] === true || EventId in echoRoot;
     const isSymbolProp = typeof property === 'symbol';
@@ -285,15 +283,15 @@ export class TypedReactiveHandler implements ReactiveHandler<ProxyTarget> {
   defineProperty(target: ProxyTarget, property: string | symbol, attributes: PropertyDescriptor): boolean {
     const echoRoot = getEchoRoot(target);
 
-    // Check readonly enforcement - mutations only allowed within Obj.change().
+    // Check readonly enforcement - mutations only allowed within Obj.update().
     // Skip check if the object is still being initialized (no ChangeId handler yet).
     // Skip for symbol properties (internal infrastructure, not user data).
     const isInitialized = ChangeId in echoRoot || EventId in echoRoot;
     const isSymbolProp = typeof property === 'symbol';
     if (isInitialized && !isSymbolProp && !isInChangeContext(echoRoot)) {
       throw new Error(
-        `Cannot modify object property "${String(property)}" outside of Obj.change(). ` +
-          'Use Obj.change(obj, (mutableObj) => { mutableObj.property = value; }) instead.',
+        `Cannot modify object property "${String(property)}" outside of Obj.update(). ` +
+          'Use Obj.update(obj, (mutableObj) => { mutableObj.property = value; }) instead.',
       );
     }
 

package/src/internal/common/proxy/typed-object.test.ts

@@ -8,7 +8,6 @@ import { describe, expect, test } from 'vitest';
 
 import { EchoObjectSchema } from '../../Entity';
 import { getSchema } from '../types';
-
 import { makeObject } from './make-object';
 import { change } from './reactive';
 
@@ -87,7 +86,7 @@ describe('EchoObjectSchema class DSL', () => {
     }
 
     {
-      // Plain object (not a reactive proxy) - doesn't need Obj.change.
+      // Plain object (not a reactive proxy) - doesn't need Obj.update.
       // Note: Schema.Schema.Type generates readonly types, so we cast to mutable for plain objects.
       type Test1 = Types.Mutable<Schema.Schema.Type<typeof schema>>;
 
@@ -101,7 +100,7 @@ describe('EchoObjectSchema class DSL', () => {
         meta: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
       }).pipe(
         EchoObjectSchema({
-          typename: 'org.dxos.type.function-trigger',
+          typename: 'org.dxos.type.functionTrigger',
           version: '0.1.0',
         }),
       );

package/src/internal/common/types/entity.ts

@@ -46,7 +46,7 @@ export const EntityKindSchema = Schema.Enums(EntityKind);
  * Typename for generic object references (Type.Obj / Ref.Ref(Obj.Unknown)).
  * Used when referencing any object without a specific schema.
  */
-export const ANY_OBJECT_TYPENAME = 'org.dxos.schema.any-object';
+export const ANY_OBJECT_TYPENAME = 'org.dxos.schema.anyObject';
 
 /**
  * Version for generic object references.

package/src/internal/common/types/meta.ts

@@ -9,7 +9,6 @@ import { invariant } from '@dxos/invariant';
 import { type Comparator, intersection } from '@dxos/util';
 
 import type * as Entity from '../../../Entity';
-
 import { type AnyProperties } from './base';
 
 /**
@@ -39,6 +38,18 @@ export const ObjectMetaSchema = Schema.Struct({
   // Defaulting to an empty array is possible but requires a bit more work.
   // TODO(dmaretskyi): In automerge this should be a map of { [tag]: boolean } for uniqueness and conflict resolution.
   tags: Schema.optional(Schema.Array(Schema.String)),
+
+  /**
+   * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).
+   * Identifies the canonical registry entry the object instance was created from.
+   */
+  key: Schema.optional(Schema.String),
+
+  /**
+   * Semantic version of the registry entry the object was created from.
+   * Must be a valid semver string (e.g. `1.2.3`).
+   */
+  version: Schema.optional(Schema.String),
 });
 
 export type ObjectMeta = Schema.Schema.Type<typeof ObjectMetaSchema>;

package/src/internal/index.ts

@@ -12,5 +12,6 @@ export * from './Format';
 export * from './JsonSchema';
 // TODO(wittjosiah): Required to ensure types are portable (need to export all types required for downstream inference).
 export * from './Obj';
+export * from './Query';
 export * from './Ref';
 export * from './Type';

package/src/testing/api.test.ts

@@ -8,7 +8,6 @@ import { describe, test } from 'vitest';
 import { raise } from '@dxos/debug';
 
 import { Entity, Obj, Ref, Relation, Type } from '../index';
-
 import { TestSchema } from './test-schema';
 
 describe('Experimental API review', () => {

package/src/testing/test-data.ts

@@ -6,125 +6,184 @@ import { DatabaseDirectory, ObjectStructure } from '@dxos/echo-protocol';
 import { DXN, ObjectId, PublicKey } from '@dxos/keys';
 
 import { Type } from '../index';
-
 import { TestSchema } from './test-schema';
 
-const spaceKey = PublicKey.random();
+// Lazy init: Cloudflare workers disallow non-determinism at module scope (e.g. random keys).
+let cachedSpaceKeyHex: string | undefined;
+const getSpaceKeyHex = (): string => {
+  if (cachedSpaceKeyHex === undefined) {
+    cachedSpaceKeyHex = PublicKey.random().toHex();
+  }
+  return cachedSpaceKeyHex;
+};
+
+let cachedPeopleAlice: DatabaseDirectory | undefined;
+let cachedPeopleBob: DatabaseDirectory | undefined;
+let cachedOrgsDxos: DatabaseDirectory | undefined;
+let cachedOrgsCyberdyne: DatabaseDirectory | undefined;
+let cachedWorksFredCyberdyne: DatabaseDirectory | undefined;
+let cachedWorksAliceAperture: DatabaseDirectory | undefined;
+let cachedTasksTask1: DatabaseDirectory | undefined;
+let cachedTasksTask2: DatabaseDirectory | undefined;
 
 // TODO(burdon): Use Obj.make.
 
 export const PEOPLE = {
-  alice: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Person)!.toString(),
-        data: {
-          name: 'Alice',
+  get alice(): DatabaseDirectory {
+    if (cachedPeopleAlice === undefined) {
+      cachedPeopleAlice = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getDXN(TestSchema.Person)!.toString(),
+            data: {
+              name: 'Alice',
+            },
+          }),
         },
-      }),
-    },
-  }),
-  bob: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Person)!.toString(),
-        data: {
-          name: 'Bob',
+      });
+    }
+    return cachedPeopleAlice;
+  },
+
+  get bob(): DatabaseDirectory {
+    if (cachedPeopleBob === undefined) {
+      cachedPeopleBob = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getDXN(TestSchema.Person)!.toString(),
+            data: {
+              name: 'Bob',
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedPeopleBob;
+  },
 };
 
 export const ORGS = {
-  dxos: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Organization)!.toString(),
-        data: {
-          name: 'DXOS',
-          founded: '2023',
+  get dxos(): DatabaseDirectory {
+    if (cachedOrgsDxos === undefined) {
+      cachedOrgsDxos = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getDXN(TestSchema.Organization)!.toString(),
+            data: {
+              name: 'DXOS',
+              founded: '2023',
+            },
+          }),
         },
-      }),
-    },
-  }),
-  cyberdyne: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Organization)!.toString(),
-        data: {
-          name: 'Cyberdyne Systems',
-          founded: '1984',
+      });
+    }
+    return cachedOrgsDxos;
+  },
+
+  get cyberdyne(): DatabaseDirectory {
+    if (cachedOrgsCyberdyne === undefined) {
+      cachedOrgsCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getDXN(TestSchema.Organization)!.toString(),
+            data: {
+              name: 'Cyberdyne Systems',
+              founded: '1984',
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedOrgsCyberdyne;
+  },
 };
 
 export const WORKS_FOR = {
-  fredWorksForCyberdyne: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeRelation({
-        type: Type.getDXN(TestSchema.EmployedBy)!.toString(),
-        source: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects!)[0]).toString() },
-        target: { '/': DXN.fromLocalObjectId(Object.keys(ORGS.cyberdyne.objects!)[0]).toString() },
-        data: {
-          since: '2020',
-          position: 'Engineer',
+  get fredWorksForCyberdyne(): DatabaseDirectory {
+    if (cachedWorksFredCyberdyne === undefined) {
+      cachedWorksFredCyberdyne = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeRelation({
+            type: Type.getDXN(TestSchema.EmployedBy)!.toString(),
+            source: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects!)[0]).toString() },
+            target: { '/': DXN.fromLocalObjectId(Object.keys(ORGS.cyberdyne.objects!)[0]).toString() },
+            data: {
+              since: '2020',
+              position: 'Engineer',
+            },
+          }),
         },
-      }),
-    },
-  }),
-  aliceWorksForAperture: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeRelation({
-        type: Type.getDXN(TestSchema.EmployedBy)!.toString(),
-        source: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects!)[0]).toString() },
-        target: { '/': DXN.fromLocalObjectId(Object.keys(ORGS.dxos.objects!)[0]).toString() },
-        data: {
-          since: '2018',
-          position: 'Research Scientist',
+      });
+    }
+    return cachedWorksFredCyberdyne;
+  },
+
+  get aliceWorksForAperture(): DatabaseDirectory {
+    if (cachedWorksAliceAperture === undefined) {
+      cachedWorksAliceAperture = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeRelation({
+            type: Type.getDXN(TestSchema.EmployedBy)!.toString(),
+            source: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects!)[0]).toString() },
+            target: { '/': DXN.fromLocalObjectId(Object.keys(ORGS.dxos.objects!)[0]).toString() },
+            data: {
+              since: '2018',
+              position: 'Research Scientist',
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedWorksAliceAperture;
+  },
 };
 
 export const TASKS = {
-  task1: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Task)!.toString(),
-        data: {
-          title: 'Complete project documentation',
-          description: 'Write comprehensive documentation for the new system',
-          status: 'in-progress',
-          dueDate: '2023-12-31',
-          assignee: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects!)[0]).toString() },
+  get task1(): DatabaseDirectory {
+    if (cachedTasksTask1 === undefined) {
+      cachedTasksTask1 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getDXN(TestSchema.Task)!.toString(),
+            data: {
+              title: 'Complete project documentation',
+              description: 'Write comprehensive documentation for the new system',
+              status: 'in-progress',
+              dueDate: '2023-12-31',
+              assignee: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.bob.objects!)[0]).toString() },
+            },
+          }),
         },
-      }),
-    },
-  }),
-  task2: DatabaseDirectory.make({
-    spaceKey: spaceKey.toHex(),
-    objects: {
-      [ObjectId.random()]: ObjectStructure.makeObject({
-        type: Type.getDXN(TestSchema.Task)!.toString(),
-        data: {
-          title: 'Run experiments',
-          description: 'Conduct series of experiments on the portal device',
-          status: 'pending',
-          dueDate: '2023-11-15',
-          assignee: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects!)[0]).toString() },
+      });
+    }
+    return cachedTasksTask1;
+  },
+
+  get task2(): DatabaseDirectory {
+    if (cachedTasksTask2 === undefined) {
+      cachedTasksTask2 = DatabaseDirectory.make({
+        spaceKey: getSpaceKeyHex(),
+        objects: {
+          [ObjectId.random()]: ObjectStructure.makeObject({
+            type: Type.getDXN(TestSchema.Task)!.toString(),
+            data: {
+              title: 'Run experiments',
+              description: 'Conduct series of experiments on the portal device',
+              status: 'pending',
+              dueDate: '2023-11-15',
+              assignee: { '/': DXN.fromLocalObjectId(Object.keys(PEOPLE.alice.objects!)[0]).toString() },
+            },
+          }),
         },
-      }),
-    },
-  }),
+      });
+    }
+    return cachedTasksTask2;
+  },
 };

package/dist/lib/neutral/chunk-43Y5DOS6.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/internal/Ref/ref.ts"],
-  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport * as Effect from 'effect/Effect';\nimport * as Equal from 'effect/Equal';\nimport * as Hash from 'effect/Hash';\nimport * as Option from 'effect/Option';\nimport * as ParseResult from 'effect/ParseResult';\nimport * as Pipeable from 'effect/Pipeable';\nimport * as Schema from 'effect/Schema';\nimport * as SchemaAST from 'effect/SchemaAST';\nimport type * as Types from 'effect/Types';\n\nimport { Event } from '@dxos/async';\nimport { type CustomInspectFunction, inspectCustom } from '@dxos/debug';\nimport { EncodedReference } from '@dxos/echo-protocol';\nimport { assertArgument, invariant } from '@dxos/invariant';\nimport { DXN, ObjectId } from '@dxos/keys';\n\nimport * as Database from '../../Database';\nimport { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../Annotation';\nimport { type JsonSchemaType } from '../JsonSchema';\nimport type { AnyEntity, AnyProperties } from '../common/types';\n\n/**\n * The `$id` and `$ref` fields for an ECHO reference schema.\n */\nexport const JSON_SCHEMA_ECHO_REF_ID = '/schemas/echo/ref';\n\nexport const getSchemaReference = (property: JsonSchemaType): { typename: string } | undefined => {\n  const { $id, reference: { schema: { $ref } = {} } = {} } = property;\n  if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {\n    return { typename: DXN.parse($ref).typename };\n  }\n};\n\nexport const createSchemaReference = (typename: string): Types.DeepMutable<JsonSchemaType> => {\n  return {\n    $id: JSON_SCHEMA_ECHO_REF_ID,\n    reference: {\n      schema: {\n        $ref: DXN.fromTypename(typename).toString(),\n      },\n    },\n  };\n};\n\n/**\n * Runtime type-info for a reference extracted from effect AST.\n */\nexport type RefereneAST = {\n  /**\n   * Typename of linked schema.\n   */\n  typename: string;\n\n  /**\n   * Version of linked schema.\n   */\n  version: string;\n};\n\nexport const getReferenceAst = (ast: SchemaAST.AST): RefereneAST | undefined => {\n  if (ast._tag !== 'Declaration' || !ast.annotations[ReferenceAnnotationId]) {\n    return undefined;\n  }\n  return {\n    typename: (ast.annotations[ReferenceAnnotationId] as any).typename,\n    version: (ast.annotations[ReferenceAnnotationId] as any).version,\n  };\n};\n\nexport const RefTypeId: unique symbol = Symbol('@dxos/echo/internal/Ref');\n\n/**\n * Reference Schema.\n */\nexport interface RefSchema<T extends AnyEntity> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}\n\n/**\n * Type of the `Ref` function and extra methods attached to it.\n */\nexport interface RefFn {\n  <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>>;\n\n  /**\n   * @returns True if the object is a reference.\n   */\n  isRef: (obj: unknown) => obj is Ref<any>;\n\n  /**\n   * @returns True if the reference points to the given object id.\n   */\n  hasObjectId: (id: ObjectId) => (ref: Ref<any>) => boolean;\n\n  /**\n   * @returns True if the schema is a reference schema.\n   */\n  isRefSchema: (schema: Schema.Schema<any, any>) => schema is RefSchema<any>;\n\n  /**\n   * @returns True if the schema AST is a reference schema.\n   */\n  isRefSchemaAST: (ast: SchemaAST.AST) => boolean;\n\n  /**\n   * Constructs a reference that points to the given object.\n   */\n  // TODO(burdon): Narrow to Obj.Unknown?\n  make: <T extends AnyEntity>(object: T) => Ref<T>;\n\n  /**\n   * Constructs a reference that points to the object specified by the provided DXN.\n   */\n  fromDXN: (dxn: DXN) => Ref<any>;\n}\n\n/**\n * Schema builder for references.\n */\nexport const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>> => {\n  assertArgument(Schema.isSchema(schema), 'schema', 'Must call with an instance of effect-schema');\n  const annotation = getTypeAnnotation(schema);\n  if (annotation == null) {\n    throw new Error('Reference target must be an ECHO schema.');\n  }\n\n  return createEchoReferenceSchema(getTypeIdentifierAnnotation(schema), annotation.typename, annotation.version);\n};\n\n/**\n * Represents materialized reference to a target.\n * This is the data type for the fields marked as ref.\n */\nexport interface Ref<T> extends Pipeable.Pipeable {\n  /**\n   * Target object DXN.\n   */\n  get dxn(): DXN;\n\n  /**\n   * Returns true if the reference has a target available (inlined or resolver set).\n   */\n  get isAvailable(): boolean;\n\n  /**\n   * @returns The reference target.\n   * May return `undefined` if the object is not loaded in the working set.\n   * Accessing this property, even if it returns `undefined` will trigger the object to be loaded to the working set.\n   */\n  get target(): T | undefined;\n\n  /**\n   * @returns Promise that will resolves with the target object.\n   * Will load the object from disk if it is not present in the working set.\n   * @throws If the object is not available locally.\n   */\n  load(): Promise<T>;\n\n  /**\n   * @returns Promise that will resolves with the target object or undefined if the object is not loaded locally.\n   */\n\n  tryLoad(): Promise<T | undefined>;\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   *\n   * When serialized with toJSON, the difference is between:\n   * `{ \"/\": \"dxn:...\" }`\n   * and\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   *\n   * Clones the reference object.\n   */\n  noInline(): Ref<T>;\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   *\n   * Examples:\n   * `{ \"/\": \"dxn:...\" }`\n   * `{ \"/\": \"dxn:...\", \"target\": { ... } }`\n   */\n  encode(): EncodedReference;\n\n  [RefTypeId]: {\n    _T: T;\n  };\n}\n\nexport declare namespace Ref {\n  /**\n   * Target of the reference.\n   */\n  export type Target<R> = R extends Ref<infer U> ? U : never;\n}\n\nRef.isRef = (obj: any): obj is Ref<any> => {\n  return obj && typeof obj === 'object' && RefTypeId in obj;\n};\n\nRef.hasObjectId = (id: ObjectId) => (ref: Ref<any>) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;\n\nRef.isRefSchema = (schema: Schema.Schema<any, any>): schema is RefSchema<any> => {\n  return Ref.isRefSchemaAST(schema.ast);\n};\n\nRef.isRefSchemaAST = (ast: SchemaAST.AST): boolean => {\n  return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);\n};\n\nRef.make = <T extends AnyProperties>(obj: T): Ref<T> => {\n  if (typeof obj !== 'object' || obj === null) {\n    throw new TypeError('Expected: ECHO object.');\n  }\n\n  // TODO(dmaretskyi): Extract to `getObjectDXN` function.\n  const id = obj.id;\n  invariant(ObjectId.isValid(id), 'Invalid object ID');\n  const dxn = DXN.fromLocalObjectId(id);\n  return new RefImpl(dxn, obj);\n};\n\nRef.fromDXN = (dxn: DXN): Ref<any> => {\n  assertArgument(dxn instanceof DXN, 'dxn', 'Expected DXN');\n  return new RefImpl(dxn);\n};\n\n/**\n * `reference` field on the schema object.\n */\nexport type JsonSchemaReferenceInfo = {\n  schema: { $ref: string };\n  schemaVersion?: string;\n};\n\n/**\n * @internal\n */\n// TODO(burdon): Move to json schema and make private?\nexport const createEchoReferenceSchema = (\n  echoId: string | undefined,\n  typename: string | undefined,\n  version: string | undefined,\n): Schema.SchemaClass<Ref<any>, EncodedReference> => {\n  if (!echoId && !typename) {\n    throw new TypeError('Either echoId or typename must be provided.');\n  }\n\n  const referenceInfo: JsonSchemaReferenceInfo = {\n    schema: {\n      // TODO(dmaretskyi): Include version?\n      $ref: echoId ?? DXN.fromTypename(typename!).toString(),\n    },\n    schemaVersion: version,\n  };\n\n  // TODO(dmaretskyi): Add name and description.\n  const refSchema = Schema.declare<Ref<any>, EncodedReference, []>(\n    [],\n    {\n      encode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            if (Ref.isRef(value)) {\n              return EncodedReference.fromDXN((value as Ref<any>).dxn);\n            } else if (EncodedReference.isEncodedReference(value)) {\n              return value;\n            }\n            throw new Error('Invalid reference');\n          });\n      },\n      decode: () => {\n        return (value) =>\n          Effect.gen(function* () {\n            const dbService = yield* Effect.serviceOption(Database.Service);\n\n            // TODO(dmaretskyi): This branch seems to be taken by Schema.is\n            if (Ref.isRef(value)) {\n              if (Option.isSome(dbService)) {\n                return dbService.value.db.makeRef(value.dxn);\n              } else {\n                return value;\n              }\n            }\n\n            if (!EncodedReference.isEncodedReference(value)) {\n              return yield* Effect.fail(new ParseResult.Unexpected(value, 'reference'));\n            }\n            if (Option.isSome(dbService)) {\n              return dbService.value.db.makeRef(EncodedReference.toDXN(value));\n            } else {\n              return Ref.fromDXN(EncodedReference.toDXN(value));\n            }\n          });\n      },\n    },\n    {\n      jsonSchema: {\n        // TODO(dmaretskyi): We should remove `$id` and keep `$ref` with a fully qualified name.\n        $id: JSON_SCHEMA_ECHO_REF_ID,\n        $ref: JSON_SCHEMA_ECHO_REF_ID,\n        reference: referenceInfo,\n      },\n      [ReferenceAnnotationId]: {\n        typename: typename ?? '',\n        version,\n      },\n    },\n  );\n\n  return refSchema;\n};\n\nconst getSchemaExpectedName = (ast: SchemaAST.Annotated): string | undefined => {\n  return SchemaAST.getIdentifierAnnotation(ast).pipe(\n    Option.orElse(() => SchemaAST.getTitleAnnotation(ast)),\n    Option.orElse(() => SchemaAST.getDescriptionAnnotation(ast)),\n    Option.getOrElse(() => undefined),\n  );\n};\n\nexport interface RefResolver {\n  /**\n   * Resolve ref synchronously from the objects in the working set.\n   *\n   * @param dxn\n   * @param load If true the resolver should attempt to load the object from disk.\n   * @param onLoad Callback to call when the object is loaded.\n   */\n  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): AnyProperties | undefined;\n\n  /**\n   * Resolver ref asynchronously.\n   */\n  resolve(dxn: DXN): Promise<AnyProperties | undefined>;\n\n  // TODO(dmaretskyi): Combine with `resolve`.\n  resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined>;\n}\n\nexport class RefImpl<T> implements Ref<T> {\n  #dxn: DXN;\n  #resolver?: RefResolver = undefined;\n  #resolved = new Event<void>();\n\n  /**\n   * Target is set when the reference is created from a specific object.\n   * In this case, the target might not be in the database.\n   */\n  #target: T | undefined = undefined;\n\n  /**\n   * Callback to issue a reactive notification when object is resolved.\n   */\n  #resolverCallback = () => {\n    this.#resolved.emit();\n  };\n\n  constructor(dxn: DXN, target?: T) {\n    this.#dxn = dxn;\n    this.#target = target;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get dxn(): DXN {\n    return this.#dxn;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get isAvailable(): boolean {\n    return this.#target !== undefined || this.#resolver !== undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  get target(): T | undefined {\n    if (this.#target) {\n      return this.#target;\n    }\n\n    invariant(this.#resolver, 'Resolver is not set');\n    return this.#resolver.resolveSync(this.#dxn, true, this.#resolverCallback) as T | undefined;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async load(): Promise<T> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    const obj = await this.#resolver.resolve(this.#dxn);\n    if (obj == null) {\n      throw new Error('Object not found');\n    }\n    return obj as T;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  async tryLoad(): Promise<T | undefined> {\n    if (this.#target) {\n      return this.#target;\n    }\n    invariant(this.#resolver, 'Resolver is not set');\n    return (await this.#resolver.resolve(this.#dxn)) as T | undefined;\n  }\n\n  /**\n   * Do not inline the target object in the reference.\n   * Makes .target unavailable unless the reference is connected to a database context.\n   * Clones the reference object.\n   */\n  noInline(): RefImpl<T> {\n    const ref = new RefImpl<T>(this.#dxn, undefined);\n    ref.#resolver = this.#resolver;\n    return ref;\n  }\n\n  encode(): EncodedReference {\n    return {\n      '/': this.#dxn.toString(),\n      ...(this.#target ? { target: this.#target } : {}),\n    };\n  }\n\n  /**\n   * Serializes the reference to a JSON object.\n   * The serialization format is compatible with the IPLD-style encoded references.\n   * When a reference has a saved target (i.e. the target or object holding the reference is not in the database),\n   * the target is included in the serialized object.\n   */\n  toJSON(): EncodedReference {\n    return this.encode();\n  }\n\n  toString(): string {\n    if (this.#target) {\n      return `Ref(${this.#target.toString()})`;\n    }\n\n    return `Ref(${this.#dxn.toString()})`;\n  }\n\n  [inspectCustom]: CustomInspectFunction = (depth, options, inspect) => {\n    return this.toString();\n  };\n\n  [RefTypeId] = refVariance;\n\n  /**\n   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)\n   * to deduplicate Ref instances that point to the same object.\n   * ECHO proxies return new RefImpl instances on every property access,\n   * so without this, each access would create a separate cache entry.\n   */\n  [Hash.symbol](): number {\n    return Hash.hash(this.#dxn.toString());\n  }\n\n  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */\n  [Equal.symbol](that: Equal.Equal): boolean {\n    return that instanceof RefImpl && this.#dxn.toString() === that.dxn.toString();\n  }\n\n  /**\n   * Internal method to set the resolver.\n   *\n   * @internal\n   */\n  _setResolver(resolver: RefResolver): void {\n    this.#resolver = resolver;\n  }\n\n  /**\n   * @internal\n   */\n  _getSavedTarget(): T | undefined {\n    return this.#target;\n  }\n\n  pipe() {\n    // eslint-disable-next-line prefer-rest-params\n    return Pipeable.pipeArguments(this, arguments);\n  }\n}\n\n/**\n * Internal API for setting the reference resolver.\n */\nexport const setRefResolver = (ref: Ref<any>, resolver: RefResolver) => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  ref._setResolver(resolver);\n};\n\n/**\n * Internal API for getting the saved target on a reference.\n */\nexport const getRefSavedTarget = (ref: Ref<any>): AnyProperties | undefined => {\n  invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');\n  return ref._getSavedTarget();\n};\n\n// Used to validate reference target type.\nconst refVariance: Ref<any>[typeof RefTypeId] = {\n  _T: null as any,\n};\n\nexport const refFromEncodedReference = (encodedReference: EncodedReference, resolver?: RefResolver): Ref<any> => {\n  const dxn = DXN.parse(encodedReference['/']);\n  const ref = new RefImpl(dxn);\n\n  // TODO(dmaretskyi): Handle inline target in the encoded reference.\n\n  if (resolver) {\n    setRefResolver(ref, resolver);\n  }\n  return ref;\n};\n\nexport class StaticRefResolver implements RefResolver {\n  public objects = new Map<ObjectId, AnyProperties>();\n  public schemas = new Map<DXN.String, Schema.Schema.AnyNoContext>();\n\n  addObject(obj: AnyProperties): this {\n    this.objects.set(obj.id, obj);\n    return this;\n  }\n\n  addSchema(schema: Schema.Schema.AnyNoContext): this {\n    const dxn = getSchemaDXN(schema);\n    invariant(dxn, 'Schema has no DXN');\n    this.schemas.set(dxn.toString(), schema);\n    return this;\n  }\n\n  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): AnyProperties | undefined {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolve(dxn: DXN): Promise<AnyProperties | undefined> {\n    const id = dxn?.asEchoDXN()?.echoId;\n    if (id == null) {\n      return undefined;\n    }\n\n    return this.objects.get(id);\n  }\n\n  async resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined> {\n    return this.schemas.get(dxn.toString());\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["Effect", "Equal", "Hash", "Option", "ParseResult", "Pipeable", "Schema", "SchemaAST", "Event", "inspectCustom", "EncodedReference", "assertArgument", "invariant", "DXN", "ObjectId", "JSON_SCHEMA_ECHO_REF_ID", "getSchemaReference", "property", "$id", "reference", "schema", "$ref", "typename", "DXN", "parse", "createSchemaReference", "fromTypename", "toString", "getReferenceAst", "ast", "_tag", "annotations", "ReferenceAnnotationId", "undefined", "version", "RefTypeId", "Symbol", "Ref", "assertArgument", "isSchema", "annotation", "getTypeAnnotation", "Error", "createEchoReferenceSchema", "getTypeIdentifierAnnotation", "isRef", "obj", "hasObjectId", "id", "ref", "dxn", "isLocalObjectId", "parts", "isRefSchema", "isRefSchemaAST", "getAnnotation", "pipe", "isSome", "make", "TypeError", "invariant", "ObjectId", "isValid", "fromLocalObjectId", "RefImpl", "fromDXN", "echoId", "referenceInfo", "schemaVersion", "refSchema", "declare", "encode", "value", "gen", "EncodedReference", "isEncodedReference", "decode", "dbService", "serviceOption", "Service", "db", "makeRef", "fail", "Unexpected", "toDXN", "jsonSchema", "RefImpl", "undefined", "Event", "emit", "dxn", "target", "isAvailable", "invariant", "resolveSync", "load", "obj", "resolve", "Error", "tryLoad", "noInline", "ref", "encode", "toString", "toJSON", "inspectCustom", "depth", "options", "inspect", "RefTypeId", "refVariance", "symbol", "hash", "that", "_setResolver", "resolver", "_getSavedTarget", "pipe", "pipeArguments", "arguments", "setRefResolver", "getRefSavedTarget", "_T", "refFromEncodedReference", "encodedReference", "DXN", "parse", "StaticRefResolver", "objects", "Map", "schemas", "addObject", "set", "id", "addSchema", "schema", "getSchemaDXN", "_load", "_onLoad", "asEchoDXN", "echoId", "get", "resolveSchema"]
-}