@dxos/echo 0.8.4-main.5ea62a8 → 0.8.4-main.66e292d

package/src/Relation.ts

@@ -2,44 +2,71 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
 import { raise } from '@dxos/debug';
-import * as EchoSchema from '@dxos/echo-schema';
 import { assertArgument, invariant } from '@dxos/invariant';
-import { DXN } from '@dxos/keys';
-import { type Live, live } from '@dxos/live-object';
+import { DXN, type ObjectId } from '@dxos/keys';
+import { type Live } from '@dxos/live-object';
 import { assumeType } from '@dxos/util';
 
-import type * as Obj from './Obj';
-import type * as Type from './Type';
+import * as Entity from './Entity';
+import {
+  ATTR_RELATION_SOURCE,
+  ATTR_RELATION_TARGET,
+  type AnyEchoObject,
+  EntityKind,
+  type InternalObjectProps,
+  MetaId,
+  type ObjectMeta,
+  RelationSourceDXNId,
+  RelationSourceId,
+  RelationTargetDXNId,
+  RelationTargetId,
+  getObjectDXN,
+  getTypeAnnotation,
+  makeObject,
+} from './internal';
+import * as Obj from './Obj';
+import * as Type from './Type';
 
 /**
- * NOTE: Don't export: Relation.Relation and Relation.Any form the public API.
+ * Base type for all ECHO relations.
+ * @private
  */
 interface BaseRelation<Source, Target>
-  extends EchoSchema.HasId,
+  extends AnyEchoObject,
     Type.Relation.Endpoints<Source, Target>,
-    Type.OfKind<EchoSchema.EntityKind.Relation> {}
+    Entity.OfKind<EntityKind.Relation> {}
 
 /**
- * Relation type with specific properties.
+ * Base type for all Relations objects.
  */
-export type Relation<Source extends Obj.Any, Target extends Obj.Any, Props> = BaseRelation<Source, Target> & Props;
+export interface Any extends BaseRelation<Obj.Any, Obj.Any> {}
+
+export const Any = Schema.Struct({}).pipe(
+  Type.Relation({
+    typename: 'dxos.org/type/Any',
+    version: '0.1.0',
+    source: Obj.Any,
+    target: Obj.Any,
+  }),
+);
 
 /**
- * Base type for all ECHO relations.
+ * Relation type with specific source and target types.
  */
-export interface Any extends BaseRelation<Obj.Any, Obj.Any> {}
+export type Relation<Source extends Obj.Any, Target extends Obj.Any, Props> = BaseRelation<Source, Target> & Props;
 
-// TODO(dmaretskyi): Has to be `unique symbol`.
-export const Source: unique symbol = EchoSchema.RelationSourceId as any;
+export const Source: unique symbol = RelationSourceId as any;
 export type Source = typeof Source;
-export const Target: unique symbol = EchoSchema.RelationTargetId as any;
+
+export const Target: unique symbol = RelationTargetId as any;
 export type Target = typeof Target;
 
 type MakeProps<T extends Any> = {
-  id?: EchoSchema.ObjectId;
+  id?: ObjectId;
+  [MetaId]?: ObjectMeta;
   [Source]: T[Source];
   [Target]: T[Target];
 } & Type.Properties<T>;
@@ -56,36 +83,34 @@ type MakeProps<T extends Any> = {
 export const make = <S extends Type.Relation.Any>(
   schema: S,
   props: NoInfer<MakeProps<Schema.Schema.Type<S>>>,
-  meta?: EchoSchema.ObjectMeta,
-): Live<Schema.Schema.Type<S> & Type.OfKind<EchoSchema.EntityKind.Relation>> => {
-  assertArgument(
-    EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Relation,
-    'Expected a relation schema',
-  );
-
-  if (props[EchoSchema.MetaId] != null) {
-    meta = props[EchoSchema.MetaId] as any;
-    delete props[EchoSchema.MetaId];
+  meta?: ObjectMeta,
+): Live<Schema.Schema.Type<S> & Entity.OfKind<typeof Entity.Kind.Relation>> => {
+  assertArgument(getTypeAnnotation(schema)?.kind === EntityKind.Relation, 'schema', 'Expected a relation schema');
+
+  if (props[MetaId] != null) {
+    meta = props[MetaId] as any;
+    delete props[MetaId];
   }
 
-  const sourceDXN = EchoSchema.getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));
-  const targetDXN = EchoSchema.getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));
-  (props as any)[EchoSchema.RelationSourceDXNId] = sourceDXN;
-  (props as any)[EchoSchema.RelationTargetDXNId] = targetDXN;
+  const sourceDXN = getObjectDXN(props[Source]) ?? raise(new Error('Unresolved relation source'));
+  const targetDXN = getObjectDXN(props[Target]) ?? raise(new Error('Unresolved relation target'));
+
+  (props as any)[RelationSourceDXNId] = sourceDXN;
+  (props as any)[RelationTargetDXNId] = targetDXN;
 
-  return live<Schema.Schema.Type<S>>(schema, props as any, meta);
+  return makeObject<Schema.Schema.Type<S>>(schema, props as any, meta);
 };
 
 export const isRelation = (value: unknown): value is Any => {
   if (typeof value !== 'object' || value === null) {
     return false;
   }
-  if (EchoSchema.ATTR_RELATION_SOURCE in value || EchoSchema.ATTR_RELATION_TARGET in value) {
+  if (ATTR_RELATION_SOURCE in value || ATTR_RELATION_TARGET in value) {
     return true;
   }
 
-  const kind = (value as any)[EchoSchema.EntityKindId];
-  return kind === EchoSchema.EntityKind.Relation;
+  const kind = (value as any)[Entity.KindId];
+  return kind === EntityKind.Relation;
 };
 
 /**
@@ -94,8 +119,8 @@ export const isRelation = (value: unknown): value is Any => {
  */
 export const getSourceDXN = (value: Any): DXN => {
   assertArgument(isRelation(value), 'Expected a relation');
-  assumeType<EchoSchema.InternalObjectProps>(value);
-  const dxn = (value as EchoSchema.InternalObjectProps)[EchoSchema.RelationSourceDXNId];
+  assumeType<InternalObjectProps>(value);
+  const dxn = (value as InternalObjectProps)[RelationSourceDXNId];
   invariant(dxn instanceof DXN);
   return dxn;
 };
@@ -106,8 +131,8 @@ export const getSourceDXN = (value: Any): DXN => {
  */
 export const getTargetDXN = (value: Any): DXN => {
   assertArgument(isRelation(value), 'Expected a relation');
-  assumeType<EchoSchema.InternalObjectProps>(value);
-  const dxn = (value as EchoSchema.InternalObjectProps)[EchoSchema.RelationTargetDXNId];
+  assumeType<InternalObjectProps>(value);
+  const dxn = (value as InternalObjectProps)[RelationTargetDXNId];
   invariant(dxn instanceof DXN);
   return dxn;
 };
@@ -118,8 +143,8 @@ export const getTargetDXN = (value: Any): DXN => {
  */
 export const getSource = <T extends Any>(relation: T): Type.Relation.Source<T> => {
   assertArgument(isRelation(relation), 'Expected a relation');
-  assumeType<EchoSchema.InternalObjectProps>(relation);
-  const obj = (relation as EchoSchema.InternalObjectProps)[EchoSchema.RelationSourceId];
+  assumeType<InternalObjectProps>(relation);
+  const obj = (relation as InternalObjectProps)[RelationSourceId];
   invariant(obj !== undefined, `Invalid source: ${relation.id}`);
   return obj as Type.Relation.Source<T>;
 };
@@ -130,8 +155,8 @@ export const getSource = <T extends Any>(relation: T): Type.Relation.Source<T> =
  */
 export const getTarget = <T extends Any>(relation: T): Type.Relation.Target<T> => {
   assertArgument(isRelation(relation), 'Expected a relation');
-  assumeType<EchoSchema.InternalObjectProps>(relation);
-  const obj = (relation as EchoSchema.InternalObjectProps)[EchoSchema.RelationTargetId];
+  assumeType<InternalObjectProps>(relation);
+  const obj = (relation as InternalObjectProps)[RelationTargetId];
   invariant(obj !== undefined, `Invalid target: ${relation.id}`);
   return obj as Type.Relation.Target<T>;
 };

package/src/Tag.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { LabelAnnotation, SystemTypeAnnotation } from './internal';
+import * as Obj from './Obj';
+import * as Type from './Type';
+
+export const Tag = Schema.Struct({
+  label: Schema.String,
+  hue: Schema.optional(Schema.String), // TODO(burdon): Color name?
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/Tag',
+    version: '0.1.0',
+  }),
+  LabelAnnotation.set(['label']),
+  SystemTypeAnnotation.set(true),
+);
+
+export type Tag = Schema.Schema.Type<typeof Tag>;
+
+export const make = (props: Obj.MakeProps<typeof Tag>) => Obj.make(Tag, props);
+
+// TODO(burdon): Rename Map.
+export type Map = Record<string, Tag>;
+
+export const sortTags = ({ label: a }: Tag, { label: b }: Tag) => a.localeCompare(b);
+
+export const createTagList = (tags: Map): Tag[] =>
+  Object.entries(tags)
+    .map(([id, tag]) => ({ ...tag, id }))
+    .sort(sortTags);
+
+export const findTagByLabel = (tags: Map | undefined, name: string): Tag | undefined => {
+  const entry = Object.entries(tags ?? {}).find(([_, tag]) => tag.label.toLowerCase() === name.toLowerCase());
+  return entry ? { ...entry[1], id: entry[0] } : undefined;
+};

package/src/Type.ts

@@ -2,45 +2,59 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
-import { type Simplify } from 'effect/Schema';
+import type * as Schema$ from 'effect/Schema';
 
 import { type EncodedReference } from '@dxos/echo-protocol';
-import * as EchoSchema from '@dxos/echo-schema';
-import { type ToMutable } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import type * as Keys from '@dxos/keys';
+import { type DXN } from '@dxos/keys';
+import { type ToMutable } from '@dxos/util';
+
+import type * as Entity$ from './Entity';
+import {
+  type ATTR_RELATION_SOURCE,
+  type ATTR_RELATION_TARGET,
+  EchoObjectSchema,
+  EchoRelationSchema,
+  type EchoRelationSchemaOptions,
+  EchoSchema,
+  Expando as Expando$,
+  type ExpandoEncoded,
+  PersistentSchema,
+  type PersistentSchemaEncoded,
+  Ref as Ref$,
+  type RefFn,
+  type RefSchema,
+  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 * 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
+// Entity
 //
 
-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.
- */
-// NOTE: Needed to make `isRelation` and `isObject` checks work.
-export interface OfKind<Kind extends EchoSchema.EntityKind> {
-  readonly id: Keys.ObjectId;
-  readonly [KindId]: Kind;
+export namespace Entity {
+  /**
+   * Type.Obj.Any | Type.Relation.Any.
+   */
+  export type Any = Obj.Any | Relation.Any;
 }
 
-/**
- * Base ECHO schema type.
- */
-export type Schema = EchoSchema.EchoSchema;
-
-/**
- * Returns all properties of an object or relation except for the id and kind.
- */
-export type Properties<T = any> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;
-
 //
 // Obj
 //
@@ -55,47 +69,50 @@ interface ObjJsonProps {
  * This typedef avoids `TS4023` error (name from external module cannot be used named).
  * See Effect's note on interface types.
  */
-export interface obj<Self extends Schema.Schema.Any>
-  extends EchoSchema.TypeMeta,
-    Schema.AnnotableClass<
+export interface obj<Self extends Schema$.Schema.Any>
+  extends TypeMeta,
+    Schema$.AnnotableClass<
       obj<Self>,
-      OfKind<EchoSchema.EntityKind.Object> & ToMutable<Schema.Schema.Type<Self>>,
-      Simplify<ObjJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
-      Schema.Schema.Context<Self>
+      Entity$.OfKind<typeof Entity$.Kind.Object> & ToMutable<Schema$.Schema.Type<Self>>,
+      Schema$.Simplify<ObjJsonProps & ToMutable<Schema$.Schema.Encoded<Self>>>,
+      Schema$.Schema.Context<Self>
     > {}
 
 /**
  * Object schema.
  */
 export const Obj: {
-  (opts: EchoSchema.TypeMeta): <Self extends Schema.Schema.Any>(self: Self) => obj<Self>;
-} = EchoSchema.EchoObject as any;
+  (opts: TypeMeta): <Self extends Schema$.Schema.Any>(self: Self) => obj<Self>;
+} = EchoObjectSchema as any;
 
 /**
  * Object schema type definitions.
  */
-export namespace Obj {
+export declare namespace Obj {
   /**
    * Type that represents an arbitrary schema type of an object.
    * NOTE: This is not an instance type.
    */
   // 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 = Schema.Schema.AnyNoContext;
+  export type Any = obj<Schema$.Schema.AnyNoContext>;
 }
 
 //
 // Expando
 //
 
-// 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 Expando: obj<Schema$.Schema<Expando$, ExpandoEncoded>> = Expando$ as any;
+export type Expando = obj<Schema$.Schema<Expando$, ExpandoEncoded>>;
 
-type ExpandoEncoded = Simplify<ObjJsonProps & { [key: string]: any }>;
+//
+// Schema
+//
+
+export const PersistentType: obj<Schema$.Schema<PersistentSchema, PersistentSchemaEncoded>> = PersistentSchema as any;
+export type PersistentType = obj<Schema$.Schema<PersistentSchema, PersistentSchemaEncoded>>;
 
-export const Expando: Schema.Schema<Expando, ExpandoEncoded, never> = EchoSchema.Expando as any;
+export { EchoSchema as RuntimeType };
 
 //
 // Relation
@@ -103,8 +120,8 @@ export const Expando: Schema.Schema<Expando, ExpandoEncoded, never> = EchoSchema
 
 interface RelationJsonProps {
   id: string;
-  [EchoSchema.ATTR_RELATION_SOURCE]: string;
-  [EchoSchema.ATTR_RELATION_TARGET]: string;
+  [ATTR_RELATION_SOURCE]: string;
+  [ATTR_RELATION_TARGET]: string;
 }
 
 /**
@@ -114,28 +131,29 @@ interface RelationJsonProps {
  * See Effect's note on interface types.
  */
 export interface relation<
-  Self extends Schema.Schema.Any,
-  SourceSchema extends Schema.Schema.Any,
-  TargetSchema extends Schema.Schema.Any,
-> extends EchoSchema.TypeMeta,
-    Schema.AnnotableClass<
+  Self extends Schema$.Schema.Any,
+  SourceSchema extends Schema$.Schema.Any,
+  TargetSchema extends Schema$.Schema.Any,
+> extends TypeMeta,
+    Schema$.AnnotableClass<
       relation<Self, SourceSchema, TargetSchema>,
-      OfKind<EchoSchema.EntityKind.Relation> &
-        Relation.Endpoints<Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>> &
-        ToMutable<Schema.Schema.Type<Self>>,
-      Simplify<RelationJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
-      Schema.Schema.Context<Self>
+      Entity$.OfKind<typeof Entity$.Kind.Relation> &
+        Relation.Endpoints<Schema$.Schema.Type<SourceSchema>, Schema$.Schema.Type<TargetSchema>> &
+        ToMutable<Schema$.Schema.Type<Self>>,
+      Schema$.Simplify<RelationJsonProps & ToMutable<Schema$.Schema.Encoded<Self>>>,
+      Schema$.Schema.Context<Self>
     > {}
 
 /**
  * Relation schema.
  */
 // TODO(dmaretskyi): I have to redefine the type here so that the definition uses symbols from @dxos/echo/Relation.
+// TODO(burdon): Remove?
 export const Relation: {
-  <Source extends Schema.Schema.AnyNoContext, Target extends Schema.Schema.AnyNoContext>(
-    opts: EchoSchema.EchoRelationOptions<Source, Target>,
-  ): <Self extends Schema.Schema.Any>(self: Self) => relation<Self, Source, Target>;
-} = EchoSchema.EchoRelation as any;
+  <Source extends Schema$.Schema.AnyNoContext, Target extends Schema$.Schema.AnyNoContext>(
+    opts: EchoRelationSchemaOptions<Source, Target>,
+  ): <Self extends Schema$.Schema.Any>(self: Self) => relation<Self, Source, Target>;
+} = EchoRelationSchema as any;
 
 /**
  * Relation schema type definitions.
@@ -146,7 +164,7 @@ export namespace Relation {
    * NOTE: This is not an instance type.
    */
   // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
-  export type Any = Schema.Schema.AnyNoContext;
+  export type Any = Schema$.Schema.AnyNoContext;
 
   /**
    * Get relation source type.
@@ -159,13 +177,14 @@ 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;
   };
 }
 
 //
 // Ref
+// TODO(burdon): Reconcile Type.Ref with Ref.Ref.
 //
 
 /**
@@ -174,23 +193,21 @@ 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 Schema.Schema.Any>
-  extends EchoSchema.Ref$<Schema.Schema.Type<TargetSchema>> {}
+export interface ref<TargetSchema extends Schema$.Schema.Any> extends RefSchema<Schema$.Schema.Type<TargetSchema>> {}
 
 /**
  * Ref schema.
  */
-export const Ref: <S extends Obj.Any>(schema: S) => ref<S> = EchoSchema.Ref;
+export const Ref: RefFn = Ref$;
 
-export interface Ref<T> extends Schema.SchemaClass<EchoSchema.Ref<T>, EncodedReference> {}
+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.
    */
-  export type Any = Schema.Schema<EchoSchema.Ref<any>, EncodedReference>;
+  export type Any = Schema$.Schema<Ref$<any>, EncodedReference>;
 }
 
 /**
@@ -199,16 +216,16 @@ export namespace Ref {
  * @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;
 };
@@ -217,8 +234,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;
 };
@@ -226,21 +243,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 '@dxos/echo-schema';

package/src/errors.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BaseError, type BaseErrorOptions } from '@dxos/errors';
+import { type DXN } from '@dxos/keys';
+
+export class SchemaNotFoundError extends BaseError.extend('SCHEMA_NOT_FOUND', 'Schema not found') {
+  constructor(schema: string, options?: BaseErrorOptions) {
+    super({ context: { schema }, ...options });
+  }
+}
+
+export class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND', 'Object not found') {
+  constructor(dxn: DXN, options?: BaseErrorOptions) {
+    super({ context: { dxn }, ...options });
+  }
+}

package/src/index.ts

@@ -2,12 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
+export { DXN } from '@dxos/keys';
+
+export * from './errors';
+
+// TODO(burdon): Separate namesapces for Query (Query.Query, Query.Filter, etc.)
+export * from './query';
+
+export * as Annotation from './Annotation';
+export * as Database from './Database';
+export * as Entity from './Entity';
+export * as Format from './Format';
+export * as JsonSchema from './JsonSchema';
 export * as Key from './Key';
 export * as Obj from './Obj';
 export * as Ref from './Ref';
 export * as Relation from './Relation';
+export * as Tag from './Tag';
 export * as Type from './Type';
-
-export { DXN } from '@dxos/keys';
-export { Filter, Query } from './query';
-export { type Live } from '@dxos/live-object';

package/src/internal/README.md

@@ -0,0 +1,83 @@
+## Refactor
+
+1. Remove access from outisde of @dxos/echo-db
+
+- [x] completely restructure @dxos/echo src/internal
+- [x] Remove import "." and ".."! (create lint rule).
+- [x] Unify FOUR different nests of test schema.
+- [x] Remove @deprecated from internal methods and mark @internal (e.g., getSchemaDXN).
+  - NOTE: Internal methods should not use the import \* from Obj/Type APIs.
+- [x] import ObjectId => @dxos/keys
+- [x] Entity.Any = Obj.Any | Relation.Any
+  - NOTE: Relation does not extend (in not polymorphic with) Obj.
+- [x] import LabelAnnotation => Annotation.LabelAnnotation
+- [x] import Expando => Type.Expando
+- [x] live => Obj.make
+- [x] Rename live => makeObject
+- [x] Rename {EchoObject, EchoRelation} => {EchoObjecSchema, EchoRelationSchema}
+- [x] Rename AnyProperties => AnyProperties
+- [x] Created Entity.Any (=> AnyEchoObject).
+- [x] TypeFormat => TypeFormat
+- [x] JsonSchemaType defs
+- [x] Fix database.add() input/output types and search for "Obj.Any = db.add" (also QueryResult types).
+- [x] TODO(burdon): FIX!!!
+- [x] Fix failing tests.
+- [x] Reconcile types/version with entities/model/version
+- [x] Type.Expando => Obj.Any
+- [x] Narrow QueryResult and match Schema and Object generics.
+
+2. Clean-up
+
+- [ ] TODO(wittjosiah): Find a simpler way to define this type.
+- [ ] TODO(wittjosiah): Should be Type.obj<...> or equivalent.
+- [ ] Fix Obj.instanceOf(Type.Expando...
+- [ ] Add Obj.Unknown and Relation.Unknown to match Entity.Unknown.
+- [ ] Ref.Array.targets doesn't satisfy Obj.Any because it uses AnyEchoObject.
+- [ ] Add Relation.MakeProps
+- [ ] Schema registry should return Type.Entity.Any instead of Schema.Schema.AnyNoContext.
+- [ ] Remove echo-db/AnyLiveObject<T> => Obj.Obj<T>
+- [ ] Narrow QueryResult and match Schema and Object generics.
+- [ ] Directly import JSONPath, etc. from @dxos/effect.
+- [ ] DISCUSS: Standradize $ suffix to disambuguate imports (GPT recommended).
+- [ ] Reconcile Type.Ref with Ref.Ref
+- [ ] Promote parts of src/internal/ref to Ref.ts
+- [ ] Rename AnyEchoObject => AnyEntity? (or accept that Object != Obj from naming perspective.)
+- [ ] Remove WithId => AnyEchoObject
+- [ ] Remove WithMeta => AnyEchoObject
+- [ ] BaseSchema
+- [ ] JsonPath, JsonProp, getValue, setValue => Json.Path?
+- [ ] Move EchoSchemaRegistry into hypergraph
+
+3. Audit usage from @dxos/echo-db
+
+- [ ] Ability to extract Struct from Type.Obj
+- [ ] created/updated system props (const { created } = Obj.getTimestamps)?
+- [ ] QueryFn, QueryOptions => Database
+- [ ] Datatbase.query() options?
+- [ ] Expando type is used as a fallback in many plance.
+- [ ] Standardize '@automerge/automerge' imports (A vs. next).
+
+## NOTES
+
+- Marking types as @internal (even for unexported types) erases type information.
+
+## 0.9.0
+
+- [ ] Database, Queue, Space, Type, namespaces.
+- [ ] Support class variant for types.
+- [ ] Support defaults.
+- [ ] Support effect Date, Timestamp formats.
+- [ ] Metadata for created, updated timestamps.
+- [ ] Effect team design review.
+- [ ] @category annotations to group types in the API.
+- [ ] TSdoc and LLM training for function generation.
+- [ ] Rename TypeFormat => Primitive?
+- [ ] Don't re-export effect?
+
+## Issues
+
+- [ ] Build error when changing from TypedObject using Ref$: Type 'Task' does not satisfy the constraint 'WithId' (see echo-schema/testing/schema.ts)
+- [ ] Reconcile all schema variants (Base, Immutable, TypedObject, EchoObject, etc.)
+- [ ] Consolidate getters (getType, getSchema, getTypename, getSchemaTypename, etc.)
+- [ ] ReactiveObject should specify id property? Reconcile AnyProperties, ReactiveObject, HasId, WithId, etc.
+- [ ] Can we us S.is(MyType) to detect objects with our types system? (Branding?)