@dxos/echo 0.8.4-main.72ec0f3 → 0.8.4-main.7ace549

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

@@ -5,14 +5,16 @@
 import * as Schema from 'effect/Schema';
 import { describe, expect, test } from 'vitest';
 
-import { EchoObject, TypedObject, getSchema } from '..';
+import { EchoObjectSchema } from '../entities';
+import { TypedObject } from '../object';
+import { getSchema } from '../types';
 
-import { live } from './reactive-object';
+import { makeObject } from './make-object';
 
 const Organization = Schema.Struct({
   name: Schema.String,
 }).pipe(
-  EchoObject({
+  EchoObjectSchema({
     typename: 'example.com/type/Organization',
     version: '0.1.0',
   }),
@@ -24,10 +26,13 @@ const Contact = Schema.Struct(
   {
     name: Schema.String,
   },
-  { key: Schema.String, value: Schema.Any },
+  {
+    key: Schema.String,
+    value: Schema.Any,
+  },
 ).pipe(
   Schema.partial,
-  EchoObject({
+  EchoObjectSchema({
     typename: 'example.com/type/Person',
     version: '0.1.0',
   }),
@@ -37,15 +42,15 @@ interface Contact extends Schema.Schema.Type<typeof Contact> {}
 
 const TEST_ORG: Omit<Organization, 'id'> = { name: 'Test' };
 
-describe('EchoObject class DSL', () => {
+describe('EchoObjectSchema class DSL', () => {
   test('can get object schema', async () => {
-    const obj = live(Organization, TEST_ORG);
+    const obj = makeObject(Organization, TEST_ORG);
     expect(getSchema(obj)).to.deep.eq(Organization);
   });
 
   describe('class options', () => {
     test('can assign undefined to partial fields', async () => {
-      const person = live(Contact, { name: 'John' });
+      const person = makeObject(Contact, { name: 'John' });
       person.name = undefined;
       person.recordField = 'hello';
       expect(person.name).to.be.undefined;
@@ -65,13 +70,13 @@ describe('EchoObject class DSL', () => {
     );
 
     {
-      const object = live(schema, {});
+      const object = makeObject(schema, {});
       (object.meta ??= {}).test = 100;
       expect(object.meta.test).to.eq(100);
     }
 
     {
-      const object = live(schema, {});
+      const object = makeObject(schema, {});
       object.meta = { test: { value: 300 } };
       expect(object.meta.test.value).to.eq(300);
     }
@@ -92,7 +97,7 @@ describe('EchoObject class DSL', () => {
         meta: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
       }) {}
 
-      const object = live(Test2, {});
+      const object = makeObject(Test2, {});
       (object.meta ??= {}).test = 100;
       expect(object.meta.test).to.eq(100);
     }

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

@@ -7,14 +7,15 @@ import { describe, expect, test } from 'vitest';
 
 import { DXN, ObjectId } from '@dxos/keys';
 
-import { EchoObject, create, getObjectDXN } from '../object';
+import { EchoObjectSchema, getObjectDXN } from '../entities';
+import { createObject } from '../object';
 
 import { Ref, getReferenceAst } from './ref';
 
 const Task = Schema.Struct({
   title: Schema.optional(Schema.String),
 }).pipe(
-  EchoObject({
+  EchoObjectSchema({
     typename: 'example.com/type/Task',
     version: '0.1.0',
   }),
@@ -27,7 +28,7 @@ const Contact = Schema.Struct({
   email: Schema.optional(Schema.String),
   tasks: Schema.mutable(Schema.Array(Ref(Task))),
 }).pipe(
-  EchoObject({
+  EchoObjectSchema({
     typename: 'example.com/type/Person',
     version: '0.1.0',
   }),
@@ -49,8 +50,8 @@ describe('Ref', () => {
 
   // TODO(dmaretskyi): Figure out how to expose this in the API.
   test.skip('encode with inlined target', () => {
-    const task = create(Task, { title: 'Fix bugs' });
-    const contact = create(Contact, { name: 'John Doe', tasks: [Ref.make(task)] });
+    const task = createObject(Task, { title: 'Fix bugs' });
+    const contact = createObject(Contact, { name: 'John Doe', tasks: [Ref.make(task)] });
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
@@ -70,8 +71,8 @@ describe('Ref', () => {
   });
 
   test('encode without inlining target', () => {
-    const task = create(Task, { title: 'Fix bugs' });
-    const contact = create(Contact, { name: 'John Doe', tasks: [Ref.make(task).noInline()] });
+    const task = createObject(Task, { title: 'Fix bugs' });
+    const contact = createObject(Contact, { name: 'John Doe', tasks: [Ref.make(task).noInline()] });
 
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({

package/src/internal/ref/ref.ts

@@ -13,16 +13,15 @@ import { compositeRuntime } from '@dxos/echo-signals/runtime';
 import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN, ObjectId } from '@dxos/keys';
 
-import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../ast';
+import { ReferenceAnnotationId, getSchemaDXN, getTypeAnnotation, getTypeIdentifierAnnotation } from '../annotations';
 import { type JsonSchemaType } from '../json-schema';
-import type { BaseObject, WithId } from '../types';
+import type { AnyProperties, WithId } from '../types';
 
 /**
  * The `$id` and `$ref` fields for an ECHO reference schema.
  */
 export const JSON_SCHEMA_ECHO_REF_ID = '/schemas/echo/ref';
 
-// TODO(burdon): Define return type.
 export const getSchemaReference = (property: JsonSchemaType): { typename: string } | undefined => {
   const { $id, reference: { schema: { $ref } = {} } = {} } = property;
   if ($id === JSON_SCHEMA_ECHO_REF_ID && $ref) {
@@ -71,16 +70,18 @@ export const RefTypeId: unique symbol = Symbol('@dxos/echo/internal/Ref');
 /**
  * Reference Schema.
  */
-export interface Ref$<T extends WithId> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}
+export interface RefSchema<T extends WithId> extends Schema.SchemaClass<Ref<T>, EncodedReference> {}
 
-// Type of the `Ref` function and extra methods attached to it.
+/**
+ * Type of the `Ref` function and extra methods attached to it.
+ */
 export interface RefFn {
-  <S extends Schema.Schema.Any>(schema: S): Ref$<Schema.Schema.Type<S>>;
+  <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>>;
 
   /**
    * @returns True if the object is a reference.
    */
-  isRef: (obj: any) => obj is Ref<any>;
+  isRef: (obj: unknown) => obj is Ref<any>;
 
   /**
    * @returns True if the reference points to the given object id.
@@ -90,7 +91,7 @@ export interface RefFn {
   /**
    * @returns True if the schema is a reference schema.
    */
-  isRefSchema: (schema: Schema.Schema<any, any>) => schema is Ref$<any>;
+  isRefSchema: (schema: Schema.Schema<any, any>) => schema is RefSchema<any>;
 
   /**
    * @returns True if the schema AST is a reference schema.
@@ -100,7 +101,7 @@ export interface RefFn {
   /**
    * Constructs a reference that points to the given object.
    */
-  // TODO(burdon): Tighten type of T?
+  // TODO(burdon): Narrow to Obj.Any?
   make: <T extends WithId>(object: T) => Ref<T>;
 
   /**
@@ -108,10 +109,11 @@ export interface RefFn {
    */
   fromDXN: (dxn: DXN) => Ref<any>;
 }
+
 /**
  * Schema builder for references.
  */
-export const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): Ref$<Schema.Schema.Type<S>> => {
+export const Ref: RefFn = <S extends Schema.Schema.Any>(schema: S): RefSchema<Schema.Schema.Type<S>> => {
   assertArgument(Schema.isSchema(schema), 'schema', 'Must call with an instance of effect-schema');
 
   const annotation = getTypeAnnotation(schema);
@@ -201,7 +203,7 @@ Ref.isRef = (obj: any): obj is Ref<any> => {
 
 Ref.hasObjectId = (id: ObjectId) => (ref: Ref<any>) => ref.dxn.isLocalObjectId() && ref.dxn.parts[1] === id;
 
-Ref.isRefSchema = (schema: Schema.Schema<any, any>): schema is Ref$<any> => {
+Ref.isRefSchema = (schema: Schema.Schema<any, any>): schema is RefSchema<any> => {
   return Ref.isRefSchemaAST(schema.ast);
 };
 
@@ -209,7 +211,7 @@ Ref.isRefSchemaAST = (ast: SchemaAST.AST): boolean => {
   return SchemaAST.getAnnotation(ast, ReferenceAnnotationId).pipe(Option.isSome);
 };
 
-Ref.make = <T extends BaseObject>(obj: T): Ref<T> => {
+Ref.make = <T extends AnyProperties>(obj: T): Ref<T> => {
   if (typeof obj !== 'object' || obj === null) {
     throw new TypeError('Expected: ECHO object.');
   }
@@ -242,7 +244,7 @@ export const createEchoReferenceSchema = (
   echoId: string | undefined,
   typename: string | undefined,
   version: string | undefined,
-  schemaName?: string,
+  schemaName?: string, // TODO(burdon): Not used.
 ): Schema.SchemaClass<Ref<any>, EncodedReference> => {
   if (!echoId && !typename) {
     throw new TypeError('Either echoId or typename must be provided.');
@@ -315,12 +317,12 @@ export interface RefResolver {
    * @param load If true the resolver should attempt to load the object from disk.
    * @param onLoad Callback to call when the object is loaded.
    */
-  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): BaseObject | undefined;
+  resolveSync(dxn: DXN, load: boolean, onLoad?: () => void): AnyProperties | undefined;
 
   /**
    * Resolver ref asynchronously.
    */
-  resolve(dxn: DXN): Promise<BaseObject | undefined>;
+  resolve(dxn: DXN): Promise<AnyProperties | undefined>;
 
   // TODO(dmaretskyi): Combine with `resolve`.
   resolveSchema(dxn: DXN): Promise<Schema.Schema.AnyNoContext | undefined>;
@@ -432,6 +434,7 @@ export class RefImpl<T> implements Ref<T> {
 
   /**
    * Internal method to set the resolver.
+   *
    * @internal
    */
   _setResolver(resolver: RefResolver): void {
@@ -441,6 +444,7 @@ export class RefImpl<T> implements Ref<T> {
   /**
    * Internal method to get the saved target.
    * Not the same as `target` which is resolved from the resolver.
+   *
    * @internal
    */
   _getSavedTarget(): T | undefined {
@@ -459,7 +463,7 @@ export const setRefResolver = (ref: Ref<any>, resolver: RefResolver) => {
 /**
  * Internal API for getting the saved target on a reference.
  */
-export const getRefSavedTarget = (ref: Ref<any>): BaseObject | undefined => {
+export const getRefSavedTarget = (ref: Ref<any>): AnyProperties | undefined => {
   invariant(ref instanceof RefImpl, 'Ref is not an instance of RefImpl');
   return ref._getSavedTarget();
 };
@@ -482,10 +486,10 @@ export const refFromEncodedReference = (encodedReference: EncodedReference, reso
 };
 
 export class StaticRefResolver implements RefResolver {
-  public objects = new Map<ObjectId, BaseObject>();
+  public objects = new Map<ObjectId, AnyProperties>();
   public schemas = new Map<DXN.String, Schema.Schema.AnyNoContext>();
 
-  addObject(obj: BaseObject): this {
+  addObject(obj: AnyProperties): this {
     this.objects.set(obj.id, obj);
     return this;
   }
@@ -497,7 +501,7 @@ export class StaticRefResolver implements RefResolver {
     return this;
   }
 
-  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): BaseObject | undefined {
+  resolveSync(dxn: DXN, _load: boolean, _onLoad?: () => void): AnyProperties | undefined {
     const id = dxn?.asEchoDXN()?.echoId;
     if (id == null) {
       return undefined;
@@ -506,7 +510,7 @@ export class StaticRefResolver implements RefResolver {
     return this.objects.get(id);
   }
 
-  async resolve(dxn: DXN): Promise<BaseObject | undefined> {
+  async resolve(dxn: DXN): Promise<AnyProperties | undefined> {
     const id = dxn?.asEchoDXN()?.echoId;
     if (id == null) {
       return undefined;

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

@@ -5,10 +5,9 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { FieldPath } from '../ast';
-import { FormatAnnotation, FormatEnum } from '../formats';
-import { toJsonSchema } from '../json';
-import { ECHO_ANNOTATIONS_NS_KEY } from '../json-schema';
+import { FieldPath } from '../annotations';
+import { FormatAnnotation, TypeFormat } from '../formats';
+import { ECHO_ANNOTATIONS_NS_KEY, toJsonSchema } from '../json-schema';
 import { TypedObject } from '../object';
 
 import { composeSchema } from './compose';
@@ -21,7 +20,7 @@ describe('schema composition', () => {
     }) {}
 
     const OverlaySchema = Schema.Struct({
-      email: Schema.String.pipe(FieldPath('$.email'), FormatAnnotation.set(FormatEnum.Email)),
+      email: Schema.String.pipe(FieldPath('$.email'), FormatAnnotation.set(TypeFormat.Email)),
     });
 
     const baseSchema = toJsonSchema(BaseType);
@@ -30,7 +29,7 @@ describe('schema composition', () => {
     expect(composedSchema.properties).to.deep.eq({
       email: {
         type: 'string',
-        format: FormatEnum.Email,
+        format: TypeFormat.Email,
         // TODO(dmaretskyi): Should use the new field.
         [ECHO_ANNOTATIONS_NS_KEY]: {
           meta: {

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

@@ -5,7 +5,8 @@
 import { invariant } from '@dxos/invariant';
 
 import { type JsonSchemaType } from '../json-schema';
-import { getSnapshot } from '../schema';
+
+import { getSnapshot } from './snapshot';
 
 /**
  * Creates a composite schema from the source and projection schemas.

package/src/internal/schema/echo-schema.ts

@@ -8,9 +8,8 @@ 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 '../ast';
-import { toEffectSchema, toJsonSchema } from '../json';
-import { type JsonSchemaType } from '../json-schema';
+import { type SchemaMeta, SchemaMetaSymbol, type TypeAnnotation, getTypeAnnotation } from '../annotations';
+import { type JsonSchemaType, toEffectSchema, toJsonSchema } from '../json-schema';
 import { type TypedObject, type TypedObjectPrototype } from '../object';
 
 import {
@@ -20,14 +19,15 @@ import {
   updateFieldNameInSchema,
   updateFieldsInSchema,
 } from './manipulation';
+import { PersistentSchema } from './persistent-schema';
 import { getSnapshot } from './snapshot';
-import { StoredSchema } from './stored-schema';
 
 /**
  * Base schema type.
  */
 // TODO(burdon): Merge with ImmutableSchema.
 export interface BaseSchema<A = any, I = any> extends TypedObject<A, I> {
+  // TODO(burdon): Different from mutable?
   get readonly(): boolean;
   // TODO(burdon): Change to external function.
   get mutable(): EchoSchema<A, I>;
@@ -124,8 +124,10 @@ const EchoSchemaConstructor = (): TypedObjectPrototype => {
    */
   return class {
     private static get _schema() {
-      // The field is DynamicEchoSchema in runtime, but is serialized as StoredEchoSchema in automerge.
-      return Schema.Union(StoredSchema, Schema.instanceOf(EchoSchema)).annotations(StoredSchema.ast.annotations);
+      // The field is DynamicEchoSchema in runtime, but is serialized as PersisentSchema in automerge.
+      return Schema.Union(PersistentSchema, Schema.instanceOf(EchoSchema)).annotations(
+        PersistentSchema.ast.annotations,
+      );
     }
 
     static readonly [Schema.TypeId] = schemaVariance;
@@ -159,7 +161,7 @@ const schemaVariance = {
 };
 
 /**
- * Represents a schema that is stored in the ECHO database.
+ * Represents a schema that is persisted in the ECHO database.
  * Schema can me mutable or readonly (specified by the {@link EchoSchema.readonly} field).
  *
  * Schema that can be modified at runtime via the API.
@@ -177,13 +179,13 @@ const schemaVariance = {
  * }) {}
  * ```
  *
- * The ECHO API will translate any references to StoredSchema objects to be resolved as EchoSchema objects.
+ * The ECHO API will translate any references to PersistentSchema objects to be resolved as EchoSchema objects.
  */
 export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implements BaseSchema<A, I> {
   private _schema: Schema.Schema.AnyNoContext | undefined;
   private _isDirty = true;
 
-  constructor(private readonly _storedSchema: StoredSchema) {
+  constructor(private readonly _persistentSchema: PersistentSchema) {
     super();
   }
 
@@ -196,11 +198,11 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
   }
 
   public get Type() {
-    return this._storedSchema as A;
+    return this._persistentSchema as A;
   }
 
   public get Encoded() {
-    return this._storedSchema as I;
+    return this._persistentSchema as I;
   }
 
   public get Context() {
@@ -228,11 +230,11 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
   //
 
   public get typename(): string {
-    return this._storedSchema.typename;
+    return this._persistentSchema.typename;
   }
 
   public get version(): string {
-    return this._storedSchema.version;
+    return this._persistentSchema.version;
   }
 
   public get readonly(): boolean {
@@ -250,7 +252,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    * @reactive
    */
   public get jsonSchema(): JsonSchemaType {
-    return this._storedSchema.jsonSchema;
+    return this._persistentSchema.jsonSchema;
   }
 
   /**
@@ -269,25 +271,25 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    * Id of the ECHO object containing the schema.
    */
   public get id(): ObjectId {
-    return this._storedSchema.id;
+    return this._persistentSchema.id;
   }
 
   /**
    * Short name of the schema.
    */
   public get name(): string | undefined {
-    return this._storedSchema.name;
+    return this._persistentSchema.name;
   }
 
   public get [SchemaMetaSymbol](): SchemaMeta {
-    return { id: this.id, typename: this.typename, version: this._storedSchema.version };
+    return { id: this.id, typename: this.typename, version: this._persistentSchema.version };
   }
 
   /**
-   * Reference to the underlying stored schema object.
+   * Reference to the underlying persistent schema object.
    */
-  public get storedSchema(): StoredSchema {
-    return this._storedSchema;
+  public get persistentSchema(): PersistentSchema {
+    return this._persistentSchema;
   }
 
   public getProperties(): SchemaAST.PropertySignature[] {
@@ -307,8 +309,8 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   public updateTypename(typename: string): void {
     const updated = setTypenameInSchema(this._getSchema(), typename);
-    this._storedSchema.typename = typename;
-    this._storedSchema.jsonSchema = toJsonSchema(updated);
+    this._persistentSchema.typename = typename;
+    this._persistentSchema.jsonSchema = toJsonSchema(updated);
   }
 
   /**
@@ -316,7 +318,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   public addFields(fields: Schema.Struct.Fields): void {
     const extended = addFieldsToSchema(this._getSchema(), fields);
-    this._storedSchema.jsonSchema = toJsonSchema(extended);
+    this._persistentSchema.jsonSchema = toJsonSchema(extended);
   }
 
   /**
@@ -324,7 +326,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   public updateFields(fields: Schema.Struct.Fields): void {
     const updated = updateFieldsInSchema(this._getSchema(), fields);
-    this._storedSchema.jsonSchema = toJsonSchema(updated);
+    this._persistentSchema.jsonSchema = toJsonSchema(updated);
   }
 
   /**
@@ -332,7 +334,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   public updateFieldPropertyName({ before, after }: { before: PropertyKey; after: PropertyKey }): void {
     const renamed = updateFieldNameInSchema(this._getSchema(), { before, after });
-    this._storedSchema.jsonSchema = toJsonSchema(renamed);
+    this._persistentSchema.jsonSchema = toJsonSchema(renamed);
   }
 
   /**
@@ -340,7 +342,7 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   public removeFields(fieldNames: string[]): void {
     const removed = removeFieldsFromSchema(this._getSchema(), fieldNames);
-    this._storedSchema.jsonSchema = toJsonSchema(removed);
+    this._persistentSchema.jsonSchema = toJsonSchema(removed);
   }
 
   //
@@ -359,12 +361,12 @@ export class EchoSchema<A = any, I = any> extends EchoSchemaConstructor() implem
    */
   _rebuild(): void {
     if (this._isDirty || this._schema == null) {
-      this._schema = toEffectSchema(getSnapshot(this._storedSchema.jsonSchema));
+      this._schema = toEffectSchema(getSnapshot(this._persistentSchema.jsonSchema));
       this._isDirty = false;
     }
   }
 
-  private _getSchema(): Schema.Schema.AnyNoContext {
+  _getSchema(): Schema.Schema.AnyNoContext {
     this._rebuild();
     return this._schema!;
   }

package/src/internal/schema/index.ts

@@ -3,8 +3,7 @@
 //
 
 export * from './echo-schema';
-export * from './snapshot';
-export * from './stored-schema';
-export * from './runtime-schema-registry';
 export * from './manipulation';
-export * from './echo-schema';
+export * from './persistent-schema';
+export * from './runtime-schema-registry';
+export * from './snapshot';

package/src/internal/schema/manipulation.ts

@@ -8,7 +8,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { invariant } from '@dxos/invariant';
 import { DXN } from '@dxos/keys';
 
-import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../ast';
+import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../annotations';
 
 // TODO(ZaymonFC): Do this one at a time. This might be dangerous.
 export const addFieldsToSchema = (

package/src/internal/schema/persistent-schema.ts

@@ -0,0 +1,28 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { TypenameSchema, VersionSchema } from '../annotations';
+import { EchoObjectSchema } from '../entities';
+import { JsonSchemaType } from '../json-schema';
+
+/**
+ * Persistent representation of a schema.
+ */
+// TODO(burdon): Move.
+const PersistentEchoSchema = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  typename: TypenameSchema,
+  version: VersionSchema,
+  jsonSchema: JsonSchemaType,
+}).pipe(
+  EchoObjectSchema({
+    typename: 'dxos.org/type/Schema',
+    version: '0.1.0',
+  }),
+);
+export interface PersistentSchema extends Schema.Schema.Type<typeof PersistentEchoSchema> {}
+export interface PersistentSchemaEncoded extends Schema.Schema.Encoded<typeof PersistentEchoSchema> {}
+export const PersistentSchema: Schema.Schema<PersistentSchema, PersistentSchemaEncoded> = PersistentEchoSchema;

package/src/internal/schema/runtime-schema-registry.ts

@@ -9,9 +9,9 @@ import { invariant } from '@dxos/invariant';
 import { type DXN } from '@dxos/keys';
 import { defaultMap } from '@dxos/util';
 
-import { getSchemaTypename, getSchemaVersion } from '../ast';
+import { getSchemaTypename, getSchemaVersion } from '../annotations';
 
-import { StoredSchema } from './stored-schema';
+import { PersistentSchema } from './persistent-schema';
 
 /**
  * Runtime registry of static schema objects (i.e., not Dynamic .
@@ -21,7 +21,7 @@ export class RuntimeSchemaRegistry {
   private readonly _registry = new Map<string, Schema.Schema.AnyNoContext[]>();
 
   constructor() {
-    this._registry.set(StoredSchema.typename, [StoredSchema]);
+    this._registry.set(getSchemaTypename(PersistentSchema)!, [PersistentSchema]);
   }
 
   get schemas(): Schema.Schema.AnyNoContext[] {
@@ -63,7 +63,7 @@ export class RuntimeSchemaRegistry {
     return this._registry.get(typename)?.[0];
   }
 
-  addSchema(types: Schema.Schema.AnyNoContext[]): void {
+  addSchema(types: readonly Schema.Schema.AnyNoContext[]): void {
     types.forEach((schema) => {
       const typename = getSchemaTypename(schema) ?? raise(new TypeError('Schema has no typename'));
       const version = getSchemaVersion(schema) ?? raise(new TypeError('Schema has no version'));

package/src/internal/types/base.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
+
+import { type ObjectId } from '@dxos/keys';
+
+import { type ATTR_META, type ObjectMeta } from './meta';
+
+/**
+ * Marker interface for object with an `id`.
+ */
+export interface HasId {
+  readonly id: ObjectId;
+}
+
+/**
+ * Object that has an associated typename.
+ * The typename is retrievable using {@link getTypename}.
+ * The object can be used with {@link isInstanceOf} to check if it is an instance of a schema.
+ */
+export type HasTypename = {};
+
+/**
+ * Base type for all data objects (reactive, ECHO, and other raw objects).
+ * NOTE: This describes the base type for all database objects.
+ * It is stricter than `T extends {}` or `T extends object`.
+ */
+// TODO(burdon): Make internal.
+// TODO(burdon): Prefer Record<string, unknown>.
+// TODO(burdon): Exclude "id", etc. from keys.
+export type AnyProperties = Record<string, any>;
+
+/**
+ * Canonical type for all ECHO objects.
+ */
+export interface AnyEchoObject extends HasId, HasTypename {}
+
+// TODO(dmaretskyi): Remove; this type effectively disables type safety due to `any`.
+export type WithId<T extends AnyProperties = AnyProperties> = T & HasId;
+
+export type ExcludeId<T extends AnyProperties> = Omit<T, 'id'>;
+
+export type PropertyKey<T extends AnyProperties> = Extract<keyof ExcludeId<T>, string>;
+
+// TODO(dmaretskyi): Remove. This should be using the symbol type.
+export type WithMeta = { [ATTR_META]?: ObjectMeta };
+
+/**
+ * The raw object should not include the ECHO id, but may include metadata.
+ */
+export const RawObject = <S extends Schema.Schema.AnyNoContext>(
+  schema: S,
+): Schema.Schema<ExcludeId<Schema.Schema.Type<S>> & WithMeta, Schema.Schema.Encoded<S>> => {
+  return Schema.make(SchemaAST.omit(schema.ast, ['id']));
+};