@dxos/echo 0.8.4-main.548089c → 0.8.4-main.59c2e9b

package/src/Type.test.ts

@@ -0,0 +1,52 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import * as Obj from './Obj';
+import * as Relation from './Relation';
+import { TestSchema } from './testing';
+import * as Type from './Type';
+
+describe('Type', () => {
+  describe('Type.Obj', () => {
+    test('has SchemaKindId for schema type checking', ({ expect }) => {
+      // Type.isObjectSchema uses SchemaKindId to check if a schema is an object schema.
+      expect(Type.isObjectSchema(Type.Obj)).toBe(true);
+      expect(Type.isObjectSchema(TestSchema.Person)).toBe(true);
+      expect(Type.isObjectSchema(Type.Relation)).toBe(false);
+    });
+
+    test('Schema.is validates structural compatibility only', ({ expect }) => {
+      // Schema.is does structural validation (has id field).
+      // It accepts both ECHO objects and plain objects with compatible structure.
+      expect(Schema.is(Type.Obj)({ id: 'plain-object' })).toBe(true);
+      const obj = Obj.make(TestSchema.Person, { name: 'Test' });
+      expect(Schema.is(Type.Obj)(obj)).toBe(true);
+    });
+  });
+
+  describe('Type.Relation', () => {
+    test('has SchemaKindId for schema type checking', ({ expect }) => {
+      // Type.isRelationSchema uses SchemaKindId to check if a schema is a relation schema.
+      expect(Type.isRelationSchema(Type.Relation)).toBe(true);
+      expect(Type.isRelationSchema(TestSchema.HasManager)).toBe(true);
+      expect(Type.isRelationSchema(Type.Obj)).toBe(false);
+    });
+
+    test('Schema.is validates structural compatibility only', ({ expect }) => {
+      // Schema.is does structural validation (has id field).
+      // It accepts both ECHO relations and plain objects with compatible structure.
+      expect(Schema.is(Type.Relation)({ id: 'plain-object' })).toBe(true);
+      const obj1 = Obj.make(TestSchema.Person, { name: 'Alice' });
+      const obj2 = Obj.make(TestSchema.Person, { name: 'Bob' });
+      const rel = Relation.make(TestSchema.HasManager, {
+        [Relation.Source]: obj1,
+        [Relation.Target]: obj2,
+      });
+      expect(Schema.is(Type.Relation)(rel)).toBe(true);
+    });
+  });
+});

package/src/Type.ts

@@ -2,150 +2,302 @@
 // Copyright 2025 DXOS.org
 //
 
-import type * as EffectSchema from 'effect/Schema';
+import * as Schema from 'effect/Schema';
 
 import { type EncodedReference } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
-import type * as Keys from '@dxos/keys';
+import { type DXN, type ObjectId } from '@dxos/keys';
+import { type ToMutable } from '@dxos/util';
+
+import type * as Entity$ from './Entity';
+import {
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  type ATTR_RELATION_SOURCE,
+  type ATTR_RELATION_TARGET,
+  type AnyEntity,
+  type AnyProperties,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  type EchoRelationSchemaOptions,
+  EchoSchema,
+  EntityKind,
+  PersistentSchema,
+  Ref as Ref$,
+  type RefFn,
+  type RefSchema,
+  SchemaKindId,
+  type TypeAnnotation,
+  type TypeMeta,
+  getSchemaDXN,
+  getSchemaTypename,
+  getSchemaVersion,
+  getTypeAnnotation,
+  isMutable as isMutable$,
+  toEffectSchema,
+  toJsonSchema,
+} from './internal';
+import type * as Relation$ from './Relation';
+
+// TODO(burdon): Remove toEffectSchema, toJsonSchema (moved to JsonSchema export).
+export { toEffectSchema, toJsonSchema };
 
-import { type ToMutable } from './internal';
-import * as EchoSchema from './internal';
-import type * as RelationModule from './Relation';
+/**
+ * Returns all properties of an object or relation except for the id and kind.
+ */
+export type Properties<T = any> = Omit<T, 'id' | Entity$.KindId | Relation$.Source | Relation$.Target>;
 
 //
-// Kind
+// Internal types (not exported)
 //
 
-export const KindId: unique symbol = EchoSchema.EntityKindId as any;
-export type KindId = typeof KindId;
-
-export const Kind = EchoSchema.EntityKind;
-
 /**
- * Assigns a kind to an Object or Relation instance.
+ * Type that marks a schema as an ECHO schema.
+ * The value indicates the entity kind (Object or Relation).
  */
-// NOTE: Needed to make `isRelation` and `isObject` checks work.
-export interface OfKind<Kind extends EchoSchema.EntityKind> {
-  readonly id: Keys.ObjectId;
-  readonly [KindId]: Kind;
-}
+type EchoSchemaKind<K extends EntityKind = EntityKind> = {
+  readonly [SchemaKindId]: K;
+};
 
 /**
- * Base ECHO schema type.
+ * JSON-encoded properties for objects.
  */
-export type Schema = EchoSchema.EchoSchema;
+interface ObjJsonProps {
+  id: string;
+}
 
 /**
- * Returns all properties of an object or relation except for the id and kind.
+ * JSON-encoded properties for relations.
  */
-export type Properties<T = any> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;
+interface RelationJsonProps {
+  id: string;
+  [ATTR_RELATION_SOURCE]: string;
+  [ATTR_RELATION_TARGET]: string;
+}
 
 //
-// Obj
+// Obj - Runtime schema for any ECHO object
 //
 
-interface ObjJsonProps {
-  id: string;
-}
+// Internal type for the Obj schema constant.
+// NOTE: The `any` in the type intersection is intentional - it makes this type bidirectionally
+//   assignable with specific object types (e.g., Type.Obj can be assigned to/from Meeting.Meeting).
+//   This is needed because operation schemas erase type information.
+// TODO(wittjosiah): Consider alternatives to the `any` intersection hack:
+//   - Generic operation schemas that preserve input type in output
+//   - Branded types that specific schemas also carry
+//   - Accept the limitation and require explicit type narrowing at call sites
+type ObjSchemaType = Schema.Schema<
+  any & AnyEntity & Entity$.OfKind<typeof Entity$.Kind.Object> & AnyProperties,
+  { id: string } & AnyProperties
+> &
+  EchoSchemaKind<EntityKind.Object> &
+  TypeMeta;
+
+// Internal schema definition.
+// NOTE: The EchoObjectSchema annotation is required for Type.Ref(Type.Obj) to work.
+//   The typename/version only satisfy ECHO schema machinery for reference targets.
+const ObjSchema = Schema.Struct({
+  id: Schema.String,
+}).pipe(
+  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
+  EchoObjectSchema({ typename: ANY_OBJECT_TYPENAME, version: ANY_OBJECT_VERSION }),
+);
 
 /**
- * Return type of the `Obj` schema constructor.
+ * Runtime Effect schema for any ECHO object.
+ * Use for validation, parsing, or as a reference target for collections.
  *
- * This typedef avoids `TS4023` error (name from external module cannot be used named).
- * See Effect's note on interface types.
+ * NOTE: `Schema.is(Type.Obj)` does STRUCTURAL validation only (checks for `id` field).
+ * Use `Obj.isObject()` for proper ECHO instance type guards that check the KindId brand.
+ *
+ * @example
+ * ```ts
+ * // Structural type guard (accepts any object with id field)
+ * if (Schema.is(Type.Obj)(unknownValue)) { ... }
+ *
+ * // ECHO instance type guard (checks KindId brand)
+ * if (Obj.isObject(unknownValue)) { ... }
+ *
+ * // Reference to any object type
+ * const Collection = Schema.Struct({
+ *   objects: Schema.Array(Type.Ref(Type.Obj)),
+ * }).pipe(Type.object({ typename: 'Collection', version: '0.1.0' }));
+ * ```
  */
-export interface obj<Self extends EffectSchema.Schema.Any>
-  extends EchoSchema.TypeMeta,
-    EffectSchema.AnnotableClass<
-      obj<Self>,
-      OfKind<EchoSchema.EntityKind.Object> & ToMutable<EffectSchema.Schema.Type<Self>>,
-      EffectSchema.Simplify<ObjJsonProps & ToMutable<EffectSchema.Schema.Encoded<Self>>>,
-      EffectSchema.Schema.Context<Self>
-    > {}
+// TODO(wittjosiah): Investigate if Schema.filter can validate KindId on ECHO instances.
+//   Effect Schema normalizes proxy objects to plain objects before calling filter predicates.
+//   Possible approaches: custom Schema.declare, AST manipulation, or upstream contribution.
+export const Obj: ObjSchemaType = Object.assign(ObjSchema, {
+  [SchemaKindId]: (ObjSchema as any)[SchemaKindId],
+}) as unknown as ObjSchemaType;
 
 /**
- * Object schema.
+ * TypeScript type for an ECHO object schema.
+ * `T` is the instance type produced by the schema.
+ * `Fields` is the optional struct fields type for introspection.
+ *
+ * @example
+ * ```ts
+ * const PersonSchema: Type.Obj<Person> = Schema.Struct({
+ *   name: Schema.String,
+ * }).pipe(Type.object({ typename: 'Person', version: '0.1.0' }));
+ *
+ * // Access fields for introspection:
+ * Object.keys(PersonSchema.fields); // ['name']
+ * ```
  */
-export const Obj: {
-  (opts: EchoSchema.TypeMeta): <Self extends EffectSchema.Schema.Any>(self: Self) => obj<Self>;
-} = EchoSchema.EchoObject as any;
+export interface Obj<T = any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>
+  extends TypeMeta,
+    EchoSchemaKind<EntityKind.Object>,
+    Schema.AnnotableClass<
+      Obj<T, Fields>,
+      Entity$.OfKind<typeof Entity$.Kind.Object> & T,
+      Schema.Simplify<ObjJsonProps & ToMutable<T>>,
+      never
+    > {
+  /**
+   * The fields defined in the original struct schema.
+   * Allows accessing field definitions for introspection.
+   */
+  readonly fields: Fields;
+}
 
 /**
- * Object schema type definitions.
+ * Structural base type for any ECHO object schema.
+ * Accepts both static schemas (created with Type.object()) and EchoSchema.
+ * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.
+ * Use Type.isObjectSchema() for runtime type guards.
  */
-export declare namespace Obj {
+type ObjectSchemaBase = Schema.Schema.AnyNoContext & {
+  readonly typename: string;
+  readonly version: string;
+};
+
+export namespace Obj {
   /**
-   * Type that represents an arbitrary schema type of an object.
-   * NOTE: This is not an instance type.
+   * Type that represents any ECHO object schema.
+   * Accepts both static schemas (Type.object()) and mutable schemas (EchoSchema).
    */
-  // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
-  // TODO(burdon): This erases the ECHO type info (e.g., id, typename).
-  export type Any = EffectSchema.Schema.AnyNoContext;
+  export type Any = ObjectSchemaBase;
 }
 
+/**
+ * Factory function to create an ECHO object schema.
+ * Adds object metadata annotations to an Effect schema.
+ *
+ * @example
+ * ```ts
+ * const Person = Schema.Struct({
+ *   name: Schema.String,
+ * }).pipe(Type.object({ typename: 'example.com/type/Person', version: '0.1.0' }));
+ * ```
+ */
+export const object: {
+  (opts: TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;
+} = EchoObjectSchema as any;
+
 //
-// Expando
+// PersistentType (Schema stored in database)
 //
 
-// TODO(burdon): We're using Expando in many places as a base type.
-export interface Expando extends OfKind<EchoSchema.EntityKind.Object> {
-  [key: string]: any;
-}
+export const PersistentType: Obj<PersistentSchema> = PersistentSchema as any;
 
-type ExpandoEncoded = EffectSchema.Simplify<ObjJsonProps & { [key: string]: any }>;
+export interface PersistentType extends Schema.Schema.Type<typeof PersistentType> {}
 
-export const Expando: EffectSchema.Schema<Expando, ExpandoEncoded, never> = EchoSchema.Expando as any;
+export { EchoSchema as RuntimeType };
 
 //
-// Relation
+// Relation - Runtime schema for any ECHO relation
 //
 
-interface RelationJsonProps {
-  id: string;
-  [EchoSchema.ATTR_RELATION_SOURCE]: string;
-  [EchoSchema.ATTR_RELATION_TARGET]: string;
-}
+// Internal type for the Relation schema constant.
+type RelationSchemaType = Schema.Schema<
+  { id: ObjectId } & Record<string, unknown>,
+  { id: string } & Record<string, unknown>
+> &
+  EchoSchemaKind<EntityKind.Relation> &
+  TypeMeta;
+
+// Internal schema definition.
+// NOTE: The EchoRelationSchema annotation is required for Type.Ref(Type.Relation) to work.
+//   The typename/version/source/target only satisfy ECHO schema machinery for reference targets.
+const RelationSchema = Schema.Struct({
+  id: Schema.String,
+}).pipe(
+  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
+  EchoRelationSchema({
+    typename: 'dxos.org/schema/AnyRelation',
+    version: '0.0.0',
+    source: ObjSchema,
+    target: ObjSchema,
+  }),
+);
 
 /**
- * Return type of the `Relation` schema constructor.
+ * Runtime Effect schema for any ECHO relation.
+ * Use for validation, parsing, or as a reference target for collections.
+ * A relation has `id`, source, and target fields plus any additional properties.
  *
- * This typedef avoids `TS4023` error (name from external module cannot be used named).
- * See Effect's note on interface types.
+ * NOTE: `Schema.is(Type.Relation)` does STRUCTURAL validation only (checks for `id` field).
+ * Use `Relation.isRelation()` for proper ECHO instance type guards that check the KindId brand.
+ *
+ * @example
+ * ```ts
+ * // Structural type guard (accepts any object with id field)
+ * if (Schema.is(Type.Relation)(unknownValue)) { ... }
+ *
+ * // ECHO instance type guard (checks KindId brand)
+ * if (Relation.isRelation(unknownValue)) { ... }
+ * ```
  */
-export interface relation<
-  Self extends EffectSchema.Schema.Any,
-  SourceSchema extends EffectSchema.Schema.Any,
-  TargetSchema extends EffectSchema.Schema.Any,
-> extends EchoSchema.TypeMeta,
-    EffectSchema.AnnotableClass<
-      relation<Self, SourceSchema, TargetSchema>,
-      OfKind<EchoSchema.EntityKind.Relation> &
-        Relation.Endpoints<EffectSchema.Schema.Type<SourceSchema>, EffectSchema.Schema.Type<TargetSchema>> &
-        ToMutable<EffectSchema.Schema.Type<Self>>,
-      EffectSchema.Simplify<RelationJsonProps & ToMutable<EffectSchema.Schema.Encoded<Self>>>,
-      EffectSchema.Schema.Context<Self>
-    > {}
+export const Relation: RelationSchemaType = Object.assign(RelationSchema, {
+  [SchemaKindId]: (RelationSchema as any)[SchemaKindId],
+}) as unknown as RelationSchemaType;
 
 /**
- * Relation schema.
+ * TypeScript type for an ECHO relation schema.
+ * `T` is the instance type produced by the schema (excluding source/target).
+ * `Source` and `Target` are the endpoint types.
+ * `Fields` is the optional struct fields type for introspection.
  */
-// TODO(dmaretskyi): I have to redefine the type here so that the definition uses symbols from @dxos/echo/Relation.
-export const Relation: {
-  <Source extends EffectSchema.Schema.AnyNoContext, Target extends EffectSchema.Schema.AnyNoContext>(
-    opts: EchoSchema.EchoRelationOptions<Source, Target>,
-  ): <Self extends EffectSchema.Schema.Any>(self: Self) => relation<Self, Source, Target>;
-} = EchoSchema.EchoRelation as any;
+export interface Relation<
+  T = any,
+  Source = any,
+  Target = any,
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+> extends TypeMeta,
+    EchoSchemaKind<EntityKind.Relation>,
+    Schema.AnnotableClass<
+      Relation<T, Source, Target, Fields>,
+      Entity$.OfKind<typeof Entity$.Kind.Relation> & Relation.Endpoints<Source, Target> & T,
+      Schema.Simplify<RelationJsonProps & ToMutable<T>>,
+      never
+    > {
+  /**
+   * The fields defined in the original struct schema.
+   * Allows accessing field definitions for introspection.
+   */
+  readonly fields: Fields;
+}
 
 /**
- * Relation schema type definitions.
+ * Structural base type for any ECHO relation schema.
+ * Accepts static schemas (created with Type.relation()).
+ * NOTE: Does not include the brand symbol to avoid TS4053 declaration portability issues.
+ * Use Type.isRelationSchema() for runtime type guards.
  */
+type RelationSchemaBase = Schema.Schema.AnyNoContext & {
+  readonly typename: string;
+  readonly version: string;
+};
+
 export namespace Relation {
   /**
-   * Type that represents an arbitrary schema type of a relation.
-   * NOTE: This is not an instance type.
+   * Type that represents any ECHO relation schema.
+   * Accepts static schemas (Type.relation()).
    */
-  // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
-  export type Any = EffectSchema.Schema.AnyNoContext;
+  export type Any = RelationSchemaBase;
 
   /**
    * Get relation source type.
@@ -158,14 +310,90 @@ export namespace Relation {
   export type Target<A> = A extends Relation.Endpoints<infer _S, infer T> ? T : never;
 
   export type Endpoints<Source, Target> = {
-    [RelationModule.Source]: Source;
-    [RelationModule.Target]: Target;
+    [Relation$.Source]: Source;
+    [Relation$.Target]: Target;
   };
 }
 
+/**
+ * Factory function to create an ECHO relation schema.
+ * Adds relation metadata annotations to an Effect schema.
+ *
+ * @example
+ * ```ts
+ * const WorksFor = Schema.Struct({
+ *   role: Schema.String,
+ * }).pipe(Type.relation({
+ *   typename: 'example.com/type/WorksFor',
+ *   version: '0.1.0',
+ *   source: Person,
+ *   target: Company,
+ * }));
+ * ```
+ */
+export const relation: {
+  <SourceSchema extends Schema.Schema.AnyNoContext, TargetSchema extends Schema.Schema.AnyNoContext>(
+    opts: EchoRelationSchemaOptions<SourceSchema, TargetSchema>,
+  ): <Self extends Schema.Schema.Any>(
+    self: Self,
+  ) => Relation<Schema.Schema.Type<Self>, Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>>;
+} = EchoRelationSchema as any;
+
+//
+// Entity - Entity schema types (union of Object | Relation)
+//
+
+export namespace Entity {
+  /**
+   * Runtime Effect schema for any ECHO entity (object or relation).
+   * Use for validation, parsing, or type guards on unknown values.
+   *
+   * @example
+   * ```ts
+   * if (Schema.is(Type.Entity.Any)(unknownValue)) {
+   *   // unknownValue is an ECHO entity
+   * }
+   * ```
+   */
+  export const Any: Schema.Schema<
+    { id: ObjectId } & Record<string, unknown>,
+    { id: string } & Record<string, unknown>
+  > = Schema.Union(Obj, Relation);
+
+  /**
+   * Type alias for any ECHO entity schema (object or relation).
+   * Use this in type annotations for schema parameters.
+   */
+  export type Any = Obj.Any | Relation.Any;
+}
+
+/**
+ * Type guard to check if a schema is an object schema.
+ * NOTE: This checks SCHEMAS, not instances. Use Obj.isObject for instances.
+ */
+export const isObjectSchema = (schema: Entity.Any): schema is Obj.Any => {
+  return (schema as any)[SchemaKindId] === EntityKind.Object;
+};
+
+/**
+ * Type guard to check if a schema is a relation schema.
+ * NOTE: This checks SCHEMAS, not instances. Use Relation.isRelation for instances.
+ */
+export const isRelationSchema = (schema: Entity.Any): schema is Relation.Any => {
+  return (schema as any)[SchemaKindId] === EntityKind.Relation;
+};
+
 //
 // Ref
 //
+// NOTE: `Type.Ref` vs `Ref.Ref`:
+// - `Type.Ref<T>` is the SCHEMA type - a schema that produces `Ref.Ref<T>` instances.
+// - `Ref.Ref<T>` is the INSTANCE type - the actual runtime ref object.
+//
+// Example:
+//   const taskRef: Ref.Ref<Task> = Ref.make(task);  // Instance
+//   const schema: Type.Ref<Task> = Type.Ref(Task);  // Schema
+//
 
 /**
  * Return type of the `Ref` schema constructor.
@@ -173,41 +401,65 @@ export namespace Relation {
  * This typedef avoids `TS4023` error (name from external module cannot be used named).
  * See Effect's note on interface types.
  */
-export interface ref<TargetSchema extends EffectSchema.Schema.Any>
-  extends EchoSchema.Ref$<EffectSchema.Schema.Type<TargetSchema>> {}
+export interface ref<TargetSchema extends Schema.Schema.Any> extends RefSchema<Schema.Schema.Type<TargetSchema>> {}
 
 /**
- * Ref schema.
+ * Factory function to create a Ref schema for the given target schema.
+ * Use this in schema definitions to declare reference fields.
+ *
+ * @example
+ * ```ts
+ * const Task = Schema.Struct({
+ *   assignee: Type.Ref(Person),  // Creates a Ref schema
+ * }).pipe(Type.object({ typename: 'Task', version: '0.1.0' }));
+ * ```
  */
-export const Ref: <S extends Obj.Any>(schema: S) => ref<S> = EchoSchema.Ref;
+export const Ref: RefFn = Ref$;
 
-export interface Ref<T> extends EffectSchema.SchemaClass<EchoSchema.Ref<T>, EncodedReference> {}
+/**
+ * TypeScript type for a Ref schema.
+ * This is the type of the SCHEMA itself, not the runtime ref instance.
+ * For the instance type, use `Ref.Ref<T>` from the Ref module.
+ *
+ * @example
+ * ```ts
+ * // Schema type annotation (rarely needed, usually inferred):
+ * const refSchema: Type.Ref<Task> = Type.Ref(Task);
+ *
+ * // Instance type annotation (use Ref.Ref instead):
+ * const refInstance: Ref.Ref<Task> = Ref.make(task);
+ * ```
+ */
+export interface Ref<T> extends Schema.SchemaClass<Ref$<T>, EncodedReference> {}
 
-// TODO(buurdon): Move to Ref?
 export namespace Ref {
   /**
-   * Type that represents an arbitrary schema type of a reference.
-   * NOTE: This is not an instance type.
+   * Type that represents any Ref schema (with unknown target type).
+   * This is a schema type, not an instance type.
    */
-  export type Any = EffectSchema.Schema<EchoSchema.Ref<any>, EncodedReference>;
+  export type Any = Schema.Schema<Ref$<any>, EncodedReference>;
 }
 
+//
+// Schema utility functions
+//
+
 /**
  * Gets the full DXN of the schema.
  * Will include the version if it's a `type` DXN.
  * @example "dxn:example.com/type/Person:0.1.0"
  * @example "dxn:echo:SSSSSSSSSS:XXXXXXXXXXXXX"
  */
-export const getDXN = (schema: Obj.Any | Relation.Any): Keys.DXN | undefined => {
-  return EchoSchema.getSchemaDXN(schema);
+export const getDXN = (schema: Entity.Any): DXN | undefined => {
+  return getSchemaDXN(schema);
 };
 
 /**
  * @param schema - Schema to get the typename from.
  * @returns The typename of the schema. Example: `example.com/type/Person`.
  */
-export const getTypename = (schema: Obj.Any | Relation.Any): string => {
-  const typename = EchoSchema.getSchemaTypename(schema);
+export const getTypename = (schema: Entity.Any): string => {
+  const typename = getSchemaTypename(schema);
   invariant(typeof typename === 'string' && !typename.startsWith('dxn:'), 'Invalid typename');
   return typename;
 };
@@ -216,8 +468,8 @@ export const getTypename = (schema: Obj.Any | Relation.Any): string => {
  * Gets the version of the schema.
  * @example 0.1.0
  */
-export const getVersion = (schema: Obj.Any | Relation.Any): string => {
-  const version = EchoSchema.getSchemaVersion(schema);
+export const getVersion = (schema: Entity.Any): string => {
+  const version = getSchemaVersion(schema);
   invariant(typeof version === 'string' && version.match(/^\d+\.\d+\.\d+$/), 'Invalid version');
   return version;
 };
@@ -225,21 +477,16 @@ export const getVersion = (schema: Obj.Any | Relation.Any): string => {
 /**
  * @returns True if the schema is mutable.
  */
-export const isMutable = EchoSchema.isMutable;
+export const isMutable = isMutable$;
 
 /**
  * ECHO type metadata.
  */
-export type Meta = EchoSchema.TypeAnnotation;
+export type Meta = TypeAnnotation;
 
 /**
  * Gets the meta data of the schema.
  */
-export const getMeta = (schema: Obj.Any | Relation.Any): Meta | undefined => {
-  return EchoSchema.getTypeAnnotation(schema);
+export const getMeta = (schema: Entity.Any): Meta | undefined => {
+  return getTypeAnnotation(schema);
 };
-
-// TODO(dmaretskyi): Remove re-exports.
-export { SpaceId, ObjectId, DXN } from '@dxos/keys';
-
-export { Format, JsonSchemaType as JsonSchema, toEffectSchema, toJsonSchema } from './internal';