@dxos/echo 0.8.4-main.bc674ce → 0.8.4-main.bd9b33e6c8

package/src/internal/{object → Obj}/json-serializer.ts

@@ -10,13 +10,15 @@ import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
 import { assumeType, deepMapValues, visitValues } from '@dxos/util';
 
+import type * as Database from '../../Database';
 import type * as Obj from '../../Obj';
-import { getTypeDXN, setTypename } from '../annotations';
+import { getTypeDXN, setTypename } from '../Annotation';
 import {
   ATTR_DELETED,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
   ATTR_SELF_DXN,
+  ObjectDatabaseId,
   type ObjectJSON,
   RelationSourceDXNId,
   RelationSourceId,
@@ -24,19 +26,21 @@ import {
   RelationTargetId,
   SelfDXNId,
   assertObjectModel,
-} from '../entities';
-import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../proxy';
-import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../ref';
+} from '../Entity';
+import { attachTypedJsonSerializer, defineHiddenProperty, typedJsonSerializer } from '../common/proxy';
+import { Ref, type RefResolver, refFromEncodedReference, setRefResolver } from '../Ref';
 import {
   ATTR_META,
+  ATTR_PARENT,
   ATTR_TYPE,
   type AnyEntity,
   EntityKind,
   KindId,
   MetaId,
   ObjectMetaSchema,
+  ParentId,
   setSchema,
-} from '../types';
+} from '../common/types';
 
 // Re-export for backward compatibility.
 export { attachTypedJsonSerializer };
@@ -68,10 +72,15 @@ export const objectToJSON = <T extends AnyEntity>(obj: T): SerializedObject<T> =
  * Performs schema validation.
  * References and schema will be resolvable if the `refResolver` is provided.
  * The function need to be async to support resolving the schema as well as the relation endpoints.
+ *
+ * @param jsonData - JSON representation of the object.
+ * @param options.refResolver - Resolver for references.
+ * @param options.dxn - Override object DXN.
+ * @param options.database - Database to associate with the object.
  */
 export const objectFromJSON = async (
   jsonData: unknown,
-  { refResolver, dxn }: { refResolver?: RefResolver; dxn?: DXN } = {},
+  { refResolver, dxn, database }: { refResolver?: RefResolver; dxn?: DXN; database?: Database.Database } = {},
 ): Promise<AnyEntity> => {
   assumeType<ObjectJSON>(jsonData);
   assertArgument(typeof jsonData === 'object' && jsonData !== null, 'jsonData', 'expect object');
@@ -81,15 +90,16 @@ export const objectFromJSON = async (
   const type = DXN.parse(jsonData[ATTR_TYPE]);
   const schema = await refResolver?.resolveSchema(type);
   invariant(schema === undefined || Schema.isSchema(schema));
+  const decodedInput = stripInternalJsonKeys(jsonData);
 
   let obj: any;
   if (schema != null) {
-    obj = await schema.pipe(Schema.decodeUnknownPromise)(jsonData);
+    obj = await schema.pipe(Schema.decodeUnknownPromise)(decodedInput);
     if (refResolver) {
       setRefResolverOnData(obj, refResolver);
     }
   } else {
-    obj = decodeGeneric(jsonData, { refResolver });
+    obj = decodeGeneric(decodedInput, { refResolver });
   }
 
   invariant(ObjectId.isValid(obj.id), 'Invalid object id');
@@ -126,10 +136,20 @@ export const objectFromJSON = async (
     });
   }
 
+  if (jsonData[ATTR_PARENT]) {
+    const parentDxn = DXN.parse(jsonData[ATTR_PARENT]);
+    const parent = (await refResolver?.resolve(parentDxn)) as Obj.Unknown | undefined;
+    defineHiddenProperty(obj, ParentId, parent);
+  }
+
   if (dxn) {
     defineHiddenProperty(obj, SelfDXNId, dxn);
   }
 
+  if (database) {
+    defineHiddenProperty(obj, ObjectDatabaseId, database);
+  }
+
   assertObjectModel(obj);
   invariant((obj as any)[ATTR_TYPE] === undefined, 'Invalid object model');
   invariant((obj as any)[ATTR_META] === undefined, 'Invalid object model');
@@ -141,6 +161,18 @@ export const objectFromJSON = async (
 };
 
 const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }) => {
+  const props = stripInternalJsonKeys(jsonData);
+
+  return deepMapValues(props, (value, visitor) => {
+    if (isEncodedReference(value)) {
+      return refFromEncodedReference(value, options.refResolver);
+    }
+
+    return visitor(value);
+  });
+};
+
+const stripInternalJsonKeys = (jsonData: unknown) => {
   const {
     [ATTR_TYPE]: _type,
     [ATTR_META]: _meta,
@@ -151,13 +183,7 @@ const decodeGeneric = (jsonData: unknown, options: { refResolver?: RefResolver }
     ...props
   } = jsonData as any;
 
-  return deepMapValues(props, (value, visitor) => {
-    if (isEncodedReference(value)) {
-      return refFromEncodedReference(value, options.refResolver);
-    }
-
-    return visitor(value);
-  });
+  return props;
 };
 
 export const setRefResolverOnData = (obj: AnyEntity, refResolver: RefResolver) => {
@@ -182,6 +208,7 @@ export const objectStructureToJson = (objectId: string, structure: ObjectStructu
     id: objectId,
     [ATTR_TYPE]: (ObjectStructure.getTypeReference(structure)?.['/'] ?? '') as DXN.String,
     [ATTR_DELETED]: ObjectStructure.isDeleted(structure),
+    [ATTR_PARENT]: ObjectStructure.getParent(structure)?.['/'] as DXN.String | undefined,
     [ATTR_RELATION_SOURCE]: ObjectStructure.getRelationSource(structure)?.['/'] as DXN.String | undefined,
     [ATTR_RELATION_TARGET]: ObjectStructure.getRelationTarget(structure)?.['/'] as DXN.String | undefined,
   };

package/src/internal/{object → Obj}/schema-validator.ts

@@ -3,4 +3,4 @@
 //
 
 // Re-export from proxy for backward compatibility.
-export { SchemaValidator, checkIdNotPresentOnSchema } from '../proxy';
+export { SchemaValidator, checkIdNotPresentOnSchema } from '../common/proxy';

package/src/internal/{object → Obj}/set-value.test.ts

@@ -17,7 +17,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['address', 'city'], 'NYC'));
 
     expect(person.address).toBeDefined();
     expect(person.address?.city).toBe('NYC');
@@ -30,7 +30,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['fields', 0, 'label'], 'Phone'));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['fields', 0, 'label'], 'Phone'));
 
     expect(Array.isArray(person.fields)).toBe(true);
     expect(person.fields?.[0].label).toBe('Phone');
@@ -45,7 +45,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'coordinates', 'lat'], 40.7128));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['address', 'coordinates', 'lat'], 40.7128));
 
     expect(person.address).toBeDefined();
     expect(person.address?.coordinates).toBeDefined();
@@ -69,10 +69,10 @@ describe('Obj.setValue', () => {
 
     const container = Obj.make(Container, { name: 'box' });
 
-    Obj.change(container, (c) => {
-      Obj.setValue(c, ['items', 0, 'value'], 10);
-      Obj.setValue(c, ['items', 1, 'value'], 20);
-      Obj.setValue(c, ['items', 2, 'value'], 30);
+    Obj.change(container, (obj) => {
+      Obj.setValue(obj, ['items', 0, 'value'], 10);
+      Obj.setValue(obj, ['items', 1, 'value'], 20);
+      Obj.setValue(obj, ['items', 2, 'value'], 30);
     });
 
     expect(container.items).toHaveLength(3);
@@ -88,7 +88,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['age'], 25));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['age'], 25));
 
     expect(person.age).toBe(25);
   });
@@ -100,7 +100,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['address', 'city'], 'NYC'));
 
     expect(person.address).toBeDefined();
     expect(person.address?.city).toBe('NYC');
@@ -114,8 +114,8 @@ describe('Obj.setValue', () => {
     });
 
     let result: any;
-    Obj.change(person, (p) => {
-      result = Obj.setValue(p, ['age'], 30);
+    Obj.change(person, (obj) => {
+      result = Obj.setValue(obj, ['age'], 30);
     });
 
     expect(result).toBe(30);
@@ -129,7 +129,7 @@ describe('Obj.setValue', () => {
       age: 25,
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['age'], 30));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['age'], 30));
 
     expect(person.age).toBe(30);
   });
@@ -142,7 +142,7 @@ describe('Obj.setValue', () => {
       address: { city: 'Boston', state: 'MA', coordinates: {} },
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['address', 'city'], 'NYC'));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['address', 'city'], 'NYC'));
 
     expect(person.address?.city).toBe('NYC');
     expect(person.address?.state).toBe('MA');
@@ -160,11 +160,11 @@ describe('Obj.setValue', () => {
 
     const matrix = Obj.make(Matrix, {});
 
-    Obj.change(matrix, (m) => {
-      Obj.setValue(m, ['values', 0, 0], 1);
-      Obj.setValue(m, ['values', 0, 1], 2);
-      Obj.setValue(m, ['values', 1, 0], 3);
-      Obj.setValue(m, ['values', 1, 1], 4);
+    Obj.change(matrix, (obj) => {
+      Obj.setValue(obj, ['values', 0, 0], 1);
+      Obj.setValue(obj, ['values', 0, 1], 2);
+      Obj.setValue(obj, ['values', 1, 0], 3);
+      Obj.setValue(obj, ['values', 1, 1], 4);
     });
 
     expect(matrix.values?.[0][0]).toBe(1);
@@ -180,8 +180,8 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => {
-      expect(() => Obj.setValue(p, [], 'value')).toThrow('Path must not be empty');
+    Obj.change(person, (obj) => {
+      expect(() => Obj.setValue(obj, [], 'value')).toThrow('Path must not be empty');
     });
   });
 
@@ -192,7 +192,7 @@ describe('Obj.setValue', () => {
       email: 'john@example.com',
     });
 
-    Obj.change(person, (p) => Obj.setValue(p, ['age'], 30));
+    Obj.change(person, (obj) => Obj.setValue(obj, ['age'], 30));
 
     expect(person.age).toBe(30);
   });
@@ -215,7 +215,7 @@ describe('Obj.setValue', () => {
     const container = Obj.make(Container, { name: 'box' });
 
     // Using string '0' for array index.
-    Obj.change(container, (c) => Obj.setValue(c, ['items', '0', 'value'], 42));
+    Obj.change(container, (obj) => Obj.setValue(obj, ['items', '0', 'value'], 42));
 
     expect(container.items?.[0].value).toBe(42);
   });
@@ -243,7 +243,7 @@ describe('Obj.setValue', () => {
 
     // This should work: setting a nested property on an array element.
     // The required 'id' field should be initialized with a default value.
-    Obj.change(todoList, (t) => Obj.setValue(t, ['tasks', 0, 'title'], 'Buy groceries'));
+    Obj.change(todoList, (obj) => Obj.setValue(obj, ['tasks', 0, 'title'], 'Buy groceries'));
 
     expect(todoList.tasks?.[0].id).toBe(''); // Default value for required String
     expect(todoList.tasks?.[0].title).toBe('Buy groceries');
@@ -270,7 +270,7 @@ describe('Obj.setValue', () => {
 
     const container = Obj.make(Container, { name: 'box' });
 
-    Obj.change(container, (c) => Obj.setValue(c, ['items', 0, 'label'], 'First Item'));
+    Obj.change(container, (obj) => Obj.setValue(obj, ['items', 0, 'label'], 'First Item'));
 
     // All required primitive fields should have default values.
     expect(container.items?.[0].id).toBe('');

package/src/internal/{object → Obj}/set-value.ts

@@ -16,8 +16,8 @@ import {
 } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
 
-import { type Mutable } from '../proxy';
-import { getSchema } from '../types';
+import { type Mutable } from '../common/proxy';
+import { getSchema } from '../common/types';
 
 /**
  * Set a deeply nested property on an object.

package/src/internal/Obj/snapshot.ts

@@ -0,0 +1,105 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { assertArgument } from '@dxos/invariant';
+import { deepMapValues } from '@dxos/util';
+
+import {
+  KindId,
+  MetaId,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  SchemaId,
+  SelfDXNId,
+  SnapshotKindId,
+  TypeId,
+} from '../common/types';
+
+/**
+ * Copy a Symbol-keyed property from source to target if it has a defined value.
+ * Handles both plain objects (symbol in source) and proxies where get returns a value
+ * but has/in returns false (e.g. ObjectDatabaseId on echo-db proxies).
+ * Optional transform clones or mutates the value before assignment (e.g. for MetaId).
+ */
+const copySymbolProperty = (
+  source: any,
+  target: any,
+  symbol: symbol,
+  transform?: (value: unknown) => unknown,
+): void => {
+  let value: unknown;
+  // Echo-db proxy getters (e.g. RelationSourceId, RelationTargetId) can throw in certain states.
+  try {
+    value = source[symbol];
+  } catch {
+    return;
+  }
+  if (value !== undefined) {
+    const finalValue = transform ? transform(value) : value;
+    Object.defineProperty(target, symbol, {
+      value: finalValue,
+      writable: false,
+      enumerable: false,
+      configurable: false,
+    });
+  }
+};
+
+/**
+ * Returns an immutable snapshot of the reactive object.
+ * The snapshot is branded with SnapshotKindId (not KindId).
+ */
+export const getSnapshot = <T extends object>(obj: T): T => {
+  assertArgument(typeof obj === 'object' && obj !== null && KindId in obj, 'obj', 'must be an entity');
+
+  const snapshot = deepMapValues(obj, (value, recurse) => {
+    // Do not recurse on references (but do recurse on arrays).
+    if (
+      typeof value === 'object' &&
+      value !== null &&
+      Object.getPrototypeOf(value) !== Object.prototype &&
+      !Array.isArray(value)
+    ) {
+      return value;
+    }
+
+    return recurse(value);
+  }) as any;
+
+  // Add SnapshotKindId brand based on original KindId.
+  if (obj != null && typeof obj === 'object' && KindId in obj) {
+    snapshot[SnapshotKindId] = (obj as any)[KindId];
+  }
+
+  // Preserve Symbol-keyed properties that are important for type introspection.
+  // These are not copied by deepMapValues since Object.keys() doesn't include symbols.
+  const source = obj as any;
+
+  // Type introspection symbols.
+  copySymbolProperty(source, snapshot, TypeId);
+  copySymbolProperty(source, snapshot, SchemaId);
+  copySymbolProperty(source, snapshot, SelfDXNId);
+
+  // Database reference (required for Obj.getDatabase to work on snapshots).
+  copySymbolProperty(source, snapshot, ObjectDatabaseId);
+  copySymbolProperty(source, snapshot, ObjectDeletedId);
+
+  // Metadata symbol. Copy arrays so the snapshot is not affected by mutations to the live meta's keys/tags.
+  copySymbolProperty(source, snapshot, MetaId, (meta: any) => ({
+    keys: [...(meta?.keys ?? [])],
+    tags: [...(meta?.tags ?? [])],
+  }));
+
+  // Relation endpoint symbols.
+  copySymbolProperty(source, snapshot, RelationSourceDXNId);
+  copySymbolProperty(source, snapshot, RelationTargetDXNId);
+  copySymbolProperty(source, snapshot, RelationSourceId);
+  copySymbolProperty(source, snapshot, RelationTargetId);
+
+  return Object.freeze(snapshot) as T;
+};

package/src/internal/{object → Obj}/typed-object.test.ts

@@ -6,13 +6,13 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
-import { EchoObjectSchema } from '../entities';
+import { EchoObjectSchema } from '../Entity';
 
 const Organization = Schema.Struct({
   name: Schema.String,
 }).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Organization',
+    typename: 'com.example.type.organization',
     version: '0.1.0',
   }),
 );
@@ -25,7 +25,7 @@ describe('EchoObjectSchema DSL', () => {
   });
 
   test('static typename accessor', async () => {
-    expect(Organization.typename).to.eq('example.com/type/Organization');
+    expect(Organization.typename).to.eq('com.example.type.organization');
   });
 
   test('expect schema', async () => {

package/src/internal/{object → Obj}/typed-object.ts

@@ -4,8 +4,8 @@
 
 import type * as Schema from 'effect/Schema';
 
-import { type TypeMeta } from '../annotations';
-import { type AnyEntity } from '../types';
+import { type TypeMeta } from '../Annotation';
+import { type AnyEntity } from '../common/types';
 
 /**
  * Definition for an object type that can be stored in an ECHO database.
@@ -14,7 +14,7 @@ import { type AnyEntity } from '../types';
  *
  * In contrast to {@link EchoSchema} this definition is not recorded in the database.
  *
- * @deprecated Use `Type.Obj.Any` from `@dxos/echo` instead.
+ * @deprecated Use `Type.AnyObj` from `@dxos/echo` instead.
  */
 export interface TypedObject<A = any, I = any> extends TypeMeta, Schema.Schema<A, I> {}
 
@@ -22,7 +22,7 @@ export interface TypedObject<A = any, I = any> extends TypeMeta, Schema.Schema<A
  * Typed object that could be used as a prototype in class definitions.
  * This is an internal API type.
  *
- * @deprecated Use `Type.Obj.Any` from `@dxos/echo` instead.
+ * @deprecated Use `Type.AnyObj` from `@dxos/echo` instead.
  */
 export interface TypedObjectPrototype<A = any, I = any> extends TypedObject<A, I> {
   /** Type constructor. */

package/src/internal/{ref → Ref}/ref-array.ts

@@ -5,7 +5,7 @@
 import { type ObjectId } from '@dxos/keys';
 import { isNonNullable } from '@dxos/util';
 
-import { type AnyEntity } from '../types';
+import { type AnyEntity } from '../common/types';
 
 import { Ref } from './ref';
 

package/src/internal/{ref → Ref}/ref.test.ts

@@ -7,8 +7,8 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN, ObjectId } from '@dxos/keys';
 
-import { EchoObjectSchema, getObjectDXN } from '../entities';
-import { createObject } from '../object';
+import { EchoObjectSchema, getObjectDXN } from '../Entity';
+import { createObject } from '../Obj';
 
 import { Ref, getReferenceAst } from './ref';
 
@@ -16,7 +16,7 @@ const Task = Schema.Struct({
   title: Schema.optional(Schema.String),
 }).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Task',
+    typename: 'com.example.type.task',
     version: '0.1.0',
   }),
 );
@@ -29,7 +29,7 @@ const Contact = Schema.Struct({
   tasks: Schema.Array(Ref(Task)),
 }).pipe(
   EchoObjectSchema({
-    typename: 'example.com/type/Person',
+    typename: 'com.example.type.person',
     version: '0.1.0',
   }),
 );

package/src/internal/{ref → Ref}/ref.ts

@@ -3,8 +3,11 @@
 //
 
 import * as Effect from 'effect/Effect';
+import * as Equal from 'effect/Equal';
+import * as Hash from 'effect/Hash';
 import * as Option from 'effect/Option';
 import * as ParseResult from 'effect/ParseResult';
+import * as Pipeable from 'effect/Pipeable';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 import type * as Types from 'effect/Types';
@@ -16,9 +19,9 @@ import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
 
 import * as Database from '../../Database';
-import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../annotations';
-import { type JsonSchemaType } from '../json-schema';
-import type { AnyEntity, AnyProperties } from '../types';
+import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../Annotation';
+import { type JsonSchemaType } from '../JsonSchema';
+import type { AnyEntity, AnyProperties } from '../common/types';
 
 /**
  * The `$id` and `$ref` fields for an ECHO reference schema.
@@ -130,7 +133,7 @@ export const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Sc
  * Represents materialized reference to a target.
  * This is the data type for the fields marked as ref.
  */
-export interface Ref<T> {
+export interface Ref<T> extends Pipeable.Pipeable {
   /**
    * Target object DXN.
    */
@@ -459,6 +462,21 @@ export class RefImpl<T> implements Ref<T> {
 
   [RefTypeId] = refVariance;
 
+  /**
+   * Effect Hash trait. Required for MutableHashMap-based caches (e.g., Atom.family)
+   * to deduplicate Ref instances that point to the same object.
+   * ECHO proxies return new RefImpl instances on every property access,
+   * so without this, each access would create a separate cache entry.
+   */
+  [Hash.symbol](): number {
+    return Hash.hash(this.#dxn.toString());
+  }
+
+  /** Effect Equal trait. See {@link Hash.symbol} for rationale. */
+  [Equal.symbol](that: Equal.Equal): boolean {
+    return that instanceof RefImpl && this.#dxn.toString() === that.dxn.toString();
+  }
+
   /**
    * Internal method to set the resolver.
    *
@@ -474,6 +492,11 @@ export class RefImpl<T> implements Ref<T> {
   _getSavedTarget(): T | undefined {
     return this.#target;
   }
+
+  pipe() {
+    // eslint-disable-next-line prefer-rest-params
+    return Pipeable.pipeArguments(this, arguments);
+  }
 }
 
 /**

package/src/internal/{schema → Type}/compose.test.ts

@@ -5,10 +5,10 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { FieldPath } from '../annotations';
-import { EchoObjectSchema } from '../entities';
-import { FormatAnnotation, TypeFormat } from '../formats';
-import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../json-schema';
+import { FieldPath } from '../Annotation';
+import { EchoObjectSchema } from '../Entity';
+import { FormatAnnotation, TypeFormat } from '../Format';
+import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../JsonSchema';
 
 import { composeSchema } from './compose';
 
@@ -17,7 +17,7 @@ describe('schema composition', () => {
     const BaseType = Schema.Struct({
       name: Schema.String,
       email: Schema.String,
-    }).pipe(EchoObjectSchema({ typename: 'example.com/Person', version: '0.1.0' }));
+    }).pipe(EchoObjectSchema({ typename: 'com.example.person', version: '0.1.0' }));
 
     const OverlaySchema = Schema.Struct({
       email: Schema.String.pipe(FieldPath('$.email'), FormatAnnotation.set(TypeFormat.Email)),

package/src/internal/{schema → Type}/compose.ts

@@ -6,7 +6,7 @@ import type * as Types from 'effect/Types';
 
 import { invariant } from '@dxos/invariant';
 
-import { type JsonSchemaType } from '../json-schema';
+import { type JsonSchemaType } from '../JsonSchema';
 
 /**
  * Creates a composite schema from the source and projection schemas.

package/src/internal/{schema → Type}/echo-schema.ts

@@ -8,11 +8,12 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { invariant } from '@dxos/invariant';
 import { type ObjectId } from '@dxos/keys';
 
-import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../annotations';
-import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../json-schema';
-import { type TypedObject, type TypedObjectPrototype, getSnapshot } from '../object';
-import { ChangeId } from '../proxy';
-import { EntityKind, SchemaKindId } from '../types';
+import type * as Type from '../../Type';
+import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../Annotation';
+import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../JsonSchema';
+import { type TypedObject, type TypedObjectPrototype, getSnapshot } from '../Obj';
+import { ChangeId } from '../common/proxy';
+import { EntityKind, SchemaKindId } from '../common/types';
 
 import {
   addFieldsToSchema,
@@ -177,7 +178,7 @@ const schemaVariance = {
  *
  * @example
  * ```ts
- * export class TableType extends Schema.Struct({...}).pipe(Type.object({ typename: 'example.org/type/Table', version: '0.1.0' })){
+ * export class TableType extends Schema.Struct({...}).pipe(Type.object({ typename: 'com.example.type.table', version: '0.1.0' })){
  *   title: Schema.String,
  *   schema: Schema.optional(ref(EchoSchema)),
  *   props: Schema.mutable(S.Array(TablePropSchema)),
@@ -192,7 +193,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
 
   /**
    * Schema kind key that marks this as an ECHO schema.
-   * Makes EchoSchema satisfy the Type.Obj.Any type.
+   * Makes EchoSchema satisfy the Type.AnyObj type.
    */
   readonly [SchemaKindId]: EntityKind.Object = EntityKind.Object;
 
@@ -304,8 +305,8 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
   /**
    * Reference to the underlying persistent schema object.
    */
-  public get persistentSchema(): PersistentSchema {
-    return this._persistentSchema;
+  public get persistentSchema(): Type.PersistentType {
+    return this._persistentSchema as Type.PersistentType;
   }
 
   public getProperties(): SchemaAST.PropertySignature[] {
@@ -399,7 +400,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   _rebuild(): void {
     if (this._isDirty || this._schema == null) {
-      this._schema = toEffectSchema(getSnapshot(this._persistentSchema.jsonSchema));
+      this._schema = toEffectSchema(getSnapshot(this._persistentSchema).jsonSchema);
       this._isDirty = false;
     }
   }