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

package/src/internal/formats/format.ts

@@ -10,6 +10,7 @@ import * as DateUtil from './date';
 import * as NumberUtil from './number';
 import * as ObjectUtil from './object';
 import * as StringUtil from './string';
+import { TypeFormat as TypeFormatEnum } from './types';
 
 // TODO(burdon): Consider factoring out to separate `@dxos/json-schema`
 // TODO(burdon): Media encoding.
@@ -22,6 +23,8 @@ import * as StringUtil from './string';
  */
 // TODO(burdon): Add fields for `examples`, `message`, etc.
 export namespace Format {
+  export import TypeFormat = TypeFormatEnum;
+
   // Strings
   export const DXN = Keys.DXN.Schema;
   export const Email = StringUtil.Email;

package/src/internal/formats/number.ts

@@ -4,7 +4,7 @@
 
 import * as Schema from 'effect/Schema';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 const encodeMultipleOf = (divisor: number) => 1 / Math.pow(10, divisor);
 
@@ -37,7 +37,7 @@ export type CurrencyAnnotation = {
 export const Currency = ({ decimals, code }: CurrencyAnnotation = { decimals: 2 }) =>
   Schema.Number.pipe(
     encodeMultiple(decimals),
-    FormatAnnotation.set(FormatEnum.Currency),
+    FormatAnnotation.set(TypeFormat.Currency),
     Schema.annotations({
       title: 'Currency',
       description: 'Currency value',
@@ -55,7 +55,7 @@ export type PercentAnnotation = {
 export const Integer = () =>
   Schema.Number.pipe(
     Schema.int(),
-    FormatAnnotation.set(FormatEnum.Integer),
+    FormatAnnotation.set(TypeFormat.Integer),
     Schema.annotations({
       title: 'Integer',
       description: 'Integer value',
@@ -69,7 +69,7 @@ export const Integer = () =>
 export const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>
   Schema.Number.pipe(
     encodeMultiple(decimals),
-    FormatAnnotation.set(FormatEnum.Percent),
+    FormatAnnotation.set(TypeFormat.Percent),
     Schema.annotations({
       title: 'Percent',
       description: 'Percentage value',
@@ -81,7 +81,7 @@ export const Percent = ({ decimals }: PercentAnnotation = { decimals: 2 }) =>
  * https://en.wikipedia.org/wiki/Unix_time
  */
 export const Timestamp = Schema.Number.pipe(
-  FormatAnnotation.set(FormatEnum.Timestamp),
+  FormatAnnotation.set(TypeFormat.Timestamp),
   Schema.annotations({
     title: 'Timestamp',
     description: 'Unix timestamp',

package/src/internal/formats/object.ts

@@ -6,7 +6,7 @@ import * as Schema from 'effect/Schema';
 
 import { clamp } from '@dxos/util';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 /**
  * GeoJSON Format
@@ -27,7 +27,7 @@ export const GeoPoint = Schema.Tuple(
     title: 'Height ASL (m)',
   }),
 ).pipe(
-  FormatAnnotation.set(FormatEnum.GeoPoint),
+  FormatAnnotation.set(TypeFormat.GeoPoint),
   Schema.annotations({
     title: 'GeoPoint',
     description: 'GeoJSON Position',

package/src/internal/formats/string.ts

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { FormatAnnotation, FormatEnum } from './types';
+import { FormatAnnotation, TypeFormat } from './types';
 
 /**
  * Email address (RFC 5321)
@@ -13,7 +13,7 @@ import { FormatAnnotation, FormatEnum } from './types';
  */
 export const Email = Schema.String.pipe(
   Schema.pattern(/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/),
-  FormatAnnotation.set(FormatEnum.Email),
+  FormatAnnotation.set(TypeFormat.Email),
   Schema.annotations({
     title: 'Email',
     description: 'Email address',
@@ -24,25 +24,25 @@ export const Email = Schema.String.pipe(
  *
  */
 // TODO(burdon): Implement.
-export const Formula = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Formula));
+export const Formula = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Formula));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const Hostname = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Hostname));
+export const Hostname = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Hostname));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const JSON = Schema.String.pipe(FormatAnnotation.set(FormatEnum.JSON));
+export const JSON = Schema.String.pipe(FormatAnnotation.set(TypeFormat.JSON));
 
 /**
  *
  */
 // TODO(burdon): Implement.
-export const Markdown = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Markdown));
+export const Markdown = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Markdown));
 
 /**
  * Regex
@@ -50,14 +50,14 @@ export const Markdown = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Markd
  * https://ecma-international.org/publications-and-standards/standards/ecma-262
  */
 // TODO(burdon): Implement.
-export const Regex = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Regex));
+export const Regex = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex));
 
 /**
  * https://datatracker.ietf.org/doc/html/rfc3986#section-1.1.3
  */
 export const URL = Schema.String.pipe(
   Schema.pattern(/^(\w+?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/i),
-  FormatAnnotation.set(FormatEnum.URL),
+  FormatAnnotation.set(TypeFormat.URL),
   Schema.annotations({
     title: 'URL',
     description: 'URL',
@@ -69,7 +69,7 @@ export const URL = Schema.String.pipe(
  * https://datatracker.ietf.org/doc/html/rfc4122
  */
 export const UUID = Schema.UUID.pipe(
-  FormatAnnotation.set(FormatEnum.UUID),
+  FormatAnnotation.set(TypeFormat.UUID),
   Schema.annotations({
     [SchemaAST.ExamplesAnnotationId]: ['3e4666bf-d5e5-4aa7-b8ce-cefe41c7568a'],
   }),

package/src/internal/formats/types.ts

@@ -7,7 +7,7 @@ import type * as JSONSchema from 'effect/JSONSchema';
 import * as Option from 'effect/Option';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { createAnnotationHelper } from '../ast';
+import { createAnnotationHelper } from '../annotations';
 import { type JsonSchemaType } from '../json-schema';
 
 // TODO(burdon): Rename PropertyType.
@@ -53,14 +53,19 @@ export const getTypeEnum = (property: JsonSchemaType): TypeEnum | undefined => {
  */
 export const FormatAnnotationId = Symbol.for('@dxos/schema/annotation/Format');
 
-export const FormatAnnotation = createAnnotationHelper<FormatEnum>(FormatAnnotationId);
+export const FormatAnnotation = createAnnotationHelper<TypeFormat>(FormatAnnotationId);
 
-export const getFormatAnnotation = (node: SchemaAST.AST): FormatEnum | undefined =>
-  Function.pipe(SchemaAST.getAnnotation<FormatEnum>(FormatAnnotationId)(node), Option.getOrUndefined);
+export const getFormatAnnotation = (node: SchemaAST.AST): TypeFormat | undefined =>
+  Function.pipe(SchemaAST.getAnnotation<TypeFormat>(FormatAnnotationId)(node), Option.getOrUndefined);
 
-// TODO(burdon): Rename to FormatType and change to discriminated union.
-export enum FormatEnum {
+// TODO(burdon): Rename Format; Change to discriminated union?
+export enum TypeFormat {
   None = 'none',
+
+  //
+  // Scalar
+  //
+
   String = 'string',
   Number = 'number',
   Boolean = 'boolean',
@@ -108,60 +113,60 @@ export enum FormatEnum {
   GeoPoint = 'lnglat',
 }
 
-export const FormatEnums = Object.values(FormatEnum).sort();
+export const FormatEnums = Object.values(TypeFormat).sort();
 
 export const PropertyKind = {
   type: TypeEnum,
-  format: FormatEnum,
+  format: TypeFormat,
 };
 
 /**
  * Default formats
  */
-export const typeToFormat: Partial<Record<TypeEnum, FormatEnum>> = {
-  [TypeEnum.String]: FormatEnum.String,
-  [TypeEnum.Number]: FormatEnum.Number,
-  [TypeEnum.Boolean]: FormatEnum.Boolean,
+export const typeToFormat: Partial<Record<TypeEnum, TypeFormat>> = {
+  [TypeEnum.String]: TypeFormat.String,
+  [TypeEnum.Number]: TypeFormat.Number,
+  [TypeEnum.Boolean]: TypeFormat.Boolean,
 };
 
 /**
  * Map of format to type.
  */
-export const formatToType: Record<FormatEnum, TypeEnum> = {
-  [FormatEnum.None]: undefined as any,
-  [FormatEnum.String]: TypeEnum.String,
-  [FormatEnum.Number]: TypeEnum.Number,
-  [FormatEnum.Boolean]: TypeEnum.Boolean,
-  [FormatEnum.Ref]: TypeEnum.Ref,
+export const formatToType: Record<TypeFormat, TypeEnum> = {
+  [TypeFormat.None]: undefined as any,
+  [TypeFormat.String]: TypeEnum.String,
+  [TypeFormat.Number]: TypeEnum.Number,
+  [TypeFormat.Boolean]: TypeEnum.Boolean,
+  [TypeFormat.Ref]: TypeEnum.Ref,
 
   // Strings
-  [FormatEnum.DID]: TypeEnum.String,
-  [FormatEnum.DXN]: TypeEnum.String,
-  [FormatEnum.Email]: TypeEnum.String,
-  [FormatEnum.Formula]: TypeEnum.String,
-  [FormatEnum.Hostname]: TypeEnum.String,
-  [FormatEnum.JSON]: TypeEnum.String,
-  [FormatEnum.Markdown]: TypeEnum.String,
-  [FormatEnum.Regex]: TypeEnum.String,
-  [FormatEnum.URL]: TypeEnum.String,
-  [FormatEnum.UUID]: TypeEnum.String,
-  [FormatEnum.SingleSelect]: TypeEnum.String,
-  [FormatEnum.MultiSelect]: TypeEnum.Object,
+  [TypeFormat.DID]: TypeEnum.String,
+  [TypeFormat.DXN]: TypeEnum.String,
+  [TypeFormat.Email]: TypeEnum.String,
+  [TypeFormat.Formula]: TypeEnum.String,
+  [TypeFormat.Hostname]: TypeEnum.String,
+  [TypeFormat.JSON]: TypeEnum.String,
+  [TypeFormat.Markdown]: TypeEnum.String,
+  [TypeFormat.Regex]: TypeEnum.String,
+  [TypeFormat.URL]: TypeEnum.String,
+  [TypeFormat.UUID]: TypeEnum.String,
+  [TypeFormat.SingleSelect]: TypeEnum.String,
+  [TypeFormat.MultiSelect]: TypeEnum.Object,
 
   // Dates
-  [FormatEnum.Date]: TypeEnum.String,
-  [FormatEnum.DateTime]: TypeEnum.String,
-  [FormatEnum.Duration]: TypeEnum.String,
-  [FormatEnum.Time]: TypeEnum.String,
+  [TypeFormat.Date]: TypeEnum.String,
+  [TypeFormat.DateTime]: TypeEnum.String,
+  [TypeFormat.Duration]: TypeEnum.String,
+  [TypeFormat.Time]: TypeEnum.String,
 
   // Numbers
-  [FormatEnum.Currency]: TypeEnum.Number,
-  [FormatEnum.Integer]: TypeEnum.Number,
-  [FormatEnum.Percent]: TypeEnum.Number,
-  [FormatEnum.Timestamp]: TypeEnum.Number,
+  [TypeFormat.Currency]: TypeEnum.Number,
+  [TypeFormat.Integer]: TypeEnum.Number,
+  [TypeFormat.Percent]: TypeEnum.Number,
+  [TypeFormat.Timestamp]: TypeEnum.Number,
 
   // Objects
-  [FormatEnum.GeoPoint]: TypeEnum.Array,
+  [TypeFormat.GeoPoint]: TypeEnum.Array,
 };
 
 /**

package/src/internal/index.ts

@@ -2,21 +2,37 @@
 // Copyright 2024 DXOS.org
 //
 
-export { JsonPath, splitJsonPath, JsonProp } from '@dxos/effect';
+// TODO(burdon): Import directly (not part of ECHO API).
+export { JsonPath, JsonProp, getValue, setValue, splitJsonPath } from '@dxos/effect';
 
-// TODO(dmaretskyi): Remove.
-export { ObjectId } from '@dxos/keys';
-export { ForeignKey } from '@dxos/echo-protocol';
-
-export * from './ast';
+export * from './annotations';
+export * from './entities';
 export * from './formats';
-export * from './json';
 export * from './json-schema';
-export * from './object';
-export * from './types';
-export { defineHiddenProperty } from '@dxos/live-object';
-export * from './projection';
-// TODO(dmaretskyi): Remove
-export { live } from './proxy/reactive-object';
 export * from './ref';
+export * from './types';
+
+// TODO(wittjosiah): Required to ensure types are portable (need to export all types required for downstream inference).
+export * from './object';
+export * from './proxy';
 export * from './schema';
+
+// export {
+//   createObject,
+//   createQueueDXN,
+//   isDeleted,
+//   objectFromJSON,
+//   objectToJSON,
+//   setRefResolverOnData,
+//   SchemaValidator,
+//   TypedObject,
+// } from './object';
+// export { makeObject } from './proxy';
+// export {
+//   type BaseSchema,
+//   EchoSchema,
+//   ImmutableSchema,
+//   RuntimeSchemaRegistry,
+//   PersistentSchema,
+//   isMutable,
+// } from './schema';

package/src/internal/{json → json-schema}/annotations.ts

@@ -4,7 +4,7 @@
 
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../ast';
+import { GeneratorAnnotationId, LabelAnnotationId, PropertyMetaAnnotationId } from '../annotations';
 import { CurrencyAnnotationId, FormatAnnotationId } from '../formats';
 import { type JsonSchemaEchoAnnotations, type JsonSchemaType } from '../json-schema';
 

package/src/internal/json-schema/index.ts

@@ -2,5 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './annotations';
 export * from './json-schema-normalize';
 export * from './json-schema-type';
+export * from './json-schema';

package/src/internal/json-schema/json-schema-type.ts

@@ -6,8 +6,8 @@ import * as Schema from 'effect/Schema';
 
 import { JsonPath, type JsonProp } from '@dxos/effect';
 
-import { EntityKindSchema } from '../ast';
-import { FormatAnnotation, FormatEnum } from '../formats';
+import { FormatAnnotation, TypeFormat } from '../formats';
+import { EntityKindSchema } from '../types';
 
 //
 // JSON Schema
@@ -206,7 +206,7 @@ const _JsonSchemaType = Schema.Struct({
   /**
    * Regex pattern for strings.
    */
-  pattern: Schema.optional(Schema.String.pipe(FormatAnnotation.set(FormatEnum.Regex))),
+  pattern: Schema.optional(Schema.String.pipe(FormatAnnotation.set(TypeFormat.Regex))),
 
   /**
    * Serialized from {@link FormatAnnotationId}.
@@ -337,6 +337,7 @@ export const JsonSchemaFields = Object.keys(_JsonSchemaType.fields);
 /**
  * https://json-schema.org/draft-07/schema
  */
+// TODO(burdon): Reconcile with @effect/Schema/JSONSchema
 export interface JsonSchemaType extends Schema.Schema.Type<Schema.mutable<typeof _JsonSchemaType>> {}
 
 export const JsonSchemaType: Schema.Schema<JsonSchemaType> = _JsonSchemaType.pipe(Schema.mutable);

package/src/internal/{json → json-schema}/json-schema.test.ts

@@ -11,22 +11,22 @@ import { type JsonProp, findAnnotation } from '@dxos/effect';
 import { ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
-import { Type } from '../..';
-import { Testing, prepareAstForCompare } from '../../testing';
+import { TestSchema, prepareAstForCompare } from '../../testing';
+import * as Type from '../../Type';
 import {
-  EntityKind,
   FieldLookupAnnotationId,
   GeneratorAnnotation,
   LabelAnnotation,
   PropertyMeta,
   getTypeAnnotation,
   getTypeIdentifierAnnotation,
-} from '../ast';
-import { Email, FormatAnnotation, FormatEnum } from '../formats';
+} from '../annotations';
+import { EchoObjectSchema } from '../entities';
+import { Email, FormatAnnotation, TypeFormat } from '../formats';
 import { JsonSchemaType, getNormalizedEchoAnnotations, getSchemaProperty, setSchemaProperty } from '../json-schema';
-import { EchoObject } from '../object';
 import { Ref, createSchemaReference, getReferenceAst, getSchemaReference } from '../ref';
-import { StoredSchema } from '../schema';
+import { PersistentSchema } from '../schema';
+import { EntityKind } from '../types';
 
 import { toEffectSchema, toJsonSchema } from './json-schema';
 
@@ -159,9 +159,9 @@ describe('effect-to-json', () => {
   });
 
   test('annotations', () => {
-    const TestSchema = Schema.Struct({
+    const TempSchema = Schema.Struct({
       name: Schema.String.annotations({ description: 'Person name', title: 'Name' }),
-      email: Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email)).annotations({
+      email: Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email)).annotations({
         description: 'Email address',
       }),
     }).pipe(
@@ -170,7 +170,8 @@ describe('effect-to-json', () => {
         version: '0.1.0',
       }),
     );
-    const jsonSchema = toJsonSchema(TestSchema);
+
+    const jsonSchema = toJsonSchema(TempSchema);
     expect(jsonSchema).to.deep.eq({
       $schema: 'http://json-schema.org/draft-07/schema#',
       $id: 'dxn:type:example.com/type/Person',
@@ -197,8 +198,16 @@ describe('effect-to-json', () => {
   });
 
   test('handles suspend -- Contact schema serialization', () => {
-    const schema = toJsonSchema(Testing.Person);
-    expect(Object.keys(schema.properties!)).toEqual(['id', 'name', 'username', 'email', 'tasks', 'address']);
+    const schema = toJsonSchema(TestSchema.Person);
+    expect(Object.keys(schema.properties!)).toEqual([
+      'id',
+      'name',
+      'username',
+      'email',
+      'tasks',
+      'employer',
+      'address',
+    ]);
   });
 
   test('reference property by ref', () => {
@@ -289,8 +298,8 @@ describe('effect-to-json', () => {
     expect(typename).to.eq(Organization.typename);
   });
 
-  test('serialize circular schema (StoredSchema)', () => {
-    const jsonSchema = toJsonSchema(StoredSchema);
+  test('serialize circular schema (PersistentSchema)', () => {
+    const jsonSchema = toJsonSchema(PersistentSchema);
     expect(Object.keys(jsonSchema.properties!).length).toBeGreaterThan(0);
 
     // TODO(dmaretskyi): Currently unable to deserialize.
@@ -313,7 +322,7 @@ describe('effect-to-json', () => {
 
   test('reference with title annotation', () => {
     const schema = Schema.Struct({
-      contact: Ref(Testing.Person).annotations({ title: 'Custom Title' }),
+      contact: Ref(TestSchema.Person).annotations({ title: 'Custom Title' }),
     });
 
     // log.info('schema before', { ast: schema.ast });
@@ -336,13 +345,13 @@ describe('effect-to-json', () => {
   });
 
   test('relation schema', () => {
-    const schema = Testing.HasManager;
+    const schema = TestSchema.EmployedBy;
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
-      $id: 'dxn:type:example.com/type/HasManager',
+      $id: 'dxn:type:example.com/type/EmployedBy',
       $schema: 'http://json-schema.org/draft-07/schema#',
       entityKind: 'relation',
-      typename: 'example.com/type/HasManager',
+      typename: 'example.com/type/EmployedBy',
       version: '0.1.0',
       relationSource: {
         // TODO(dmaretskyi): Should those point to specific schema version?
@@ -350,19 +359,22 @@ describe('effect-to-json', () => {
       },
       relationTarget: {
         // TODO(dmaretskyi): Should those point to specific schema version?
-        $ref: 'dxn:type:example.com/type/Person',
+        $ref: 'dxn:type:example.com/type/Organization',
       },
       type: 'object',
       properties: {
         id: {
           type: 'string',
         },
+        role: {
+          type: 'string',
+        },
         since: {
           type: 'string',
         },
       },
-      propertyOrder: ['since', 'id'],
-      required: ['id'],
+      propertyOrder: ['role', 'since', 'id'],
+      required: ['role', 'id'],
       additionalProperties: false,
     });
   });
@@ -372,7 +384,7 @@ describe('effect-to-json', () => {
       id: ObjectId,
       name: Schema.String,
     }).pipe(
-      EchoObject({
+      EchoObjectSchema({
         typename: 'example.com/type/Organization',
         version: '0.1.0',
       }),
@@ -498,7 +510,7 @@ describe('json-to-effect', () => {
         object: Schema.Struct({ id: Schema.String, field: Ref(Organization) }),
         echoObject: Ref(Organization),
         echoObjectArray: Schema.Array(Ref(Organization)),
-        email: Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email)),
+        email: Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email)),
         null: Schema.Null,
       } as const;
 
@@ -570,8 +582,8 @@ describe('json-to-effect', () => {
   });
 
   test('symbol annotations get compared', () => {
-    const schema1 = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Email));
-    const schema2 = Schema.String.pipe(FormatAnnotation.set(FormatEnum.Currency));
+    const schema1 = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email));
+    const schema2 = Schema.String.pipe(FormatAnnotation.set(TypeFormat.Currency));
     expect(prepareAstForCompare(schema1.ast)).not.to.deep.eq(prepareAstForCompare(schema2.ast));
   });
 
@@ -586,7 +598,7 @@ describe('json-to-effect', () => {
   });
 
   test('relation schema roundtrip', () => {
-    const schema = Testing.HasManager;
+    const schema = TestSchema.HasManager;
     const jsonSchema = toJsonSchema(schema);
     const effectSchema = toEffectSchema(jsonSchema);
     expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(schema.ast));
@@ -689,10 +701,8 @@ describe('json-to-effect', () => {
   });
 
   test('schema with optional referece', () => {
-    const TestSchema = Schema.Struct({
-      contact: Schema.optional(Ref(Testing.Person)),
-    });
-    const jsonSchema = toJsonSchema(TestSchema);
+    const TempSchema = Schema.Struct({ contact: Schema.optional(Ref(TestSchema.Person)) });
+    const jsonSchema = toJsonSchema(TempSchema);
     expect(jsonSchema).toMatchInlineSnapshot(`
       {
         "$schema": "http://json-schema.org/draft-07/schema#",
@@ -718,13 +728,13 @@ describe('json-to-effect', () => {
     `);
 
     const effectSchema = toEffectSchema(jsonSchema);
-    expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(TestSchema.ast));
+    expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(TempSchema.ast));
   });
 
   test('object nested inside another struct', () => {
     const Contact = Schema.Struct({
       name: Schema.String,
-    }).pipe(EchoObject({ typename: 'example.com/type/Person', version: '0.1.0' }));
+    }).pipe(EchoObjectSchema({ typename: 'example.com/type/Person', version: '0.1.0' }));
     const input = Schema.Struct({
       contact: Contact,
     });
@@ -776,7 +786,7 @@ describe('json-to-effect', () => {
 
 describe('reference', () => {
   test('reference annotation', () => {
-    const schema = Ref(Testing.Person);
+    const schema = Ref(TestSchema.Person);
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
       $id: '/schemas/echo/ref',
@@ -792,7 +802,7 @@ describe('reference', () => {
   });
 
   test('title annotation', () => {
-    const schema = Ref(Testing.Person).annotations({ title: 'My custom title' });
+    const schema = Ref(TestSchema.Person).annotations({ title: 'My custom title' });
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
       $schema: 'http://json-schema.org/draft-07/schema#',
@@ -813,7 +823,7 @@ describe('reference', () => {
   });
 
   test('description annotation', () => {
-    const schema = Ref(Testing.Person).annotations({ description: 'My custom description' });
+    const schema = Ref(TestSchema.Person).annotations({ description: 'My custom description' });
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
       $schema: 'http://json-schema.org/draft-07/schema#',
@@ -837,13 +847,13 @@ describe('reference', () => {
   });
 
   test('serialize and deserialize', () => {
-    const schema = Ref(Testing.Person);
+    const schema = Ref(TestSchema.Person);
     const jsonSchema = toJsonSchema(schema);
     const deserializedSchema = toEffectSchema(jsonSchema);
     const refAst = getReferenceAst(deserializedSchema.ast);
     expect(refAst).toEqual({
-      typename: Testing.Person.typename,
-      version: Testing.Person.version,
+      typename: TestSchema.Person.typename,
+      version: TestSchema.Person.version,
     });
   });
 });

package/src/internal/{json → json-schema}/json-schema.ts

@@ -17,19 +17,24 @@ import { DXN, ObjectId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { clearUndefined, orderKeys, removeProperties } from '@dxos/util';
 
-import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../ast';
-import { EntityKind, EntityKindSchema } from '../ast';
+import {
+  type TypeAnnotation,
+  TypeAnnotationId,
+  TypeIdentifierAnnotationId,
+  makeTypeJsonSchemaAnnotation,
+} from '../annotations';
+import { Expando } from '../entities';
+import { type JsonSchemaReferenceInfo, Ref, createEchoReferenceSchema } from '../ref';
+import { EntityKind, EntityKindSchema } from '../types';
+
+import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
 import {
   ECHO_ANNOTATIONS_NS_DEPRECATED_KEY,
   ECHO_ANNOTATIONS_NS_KEY,
   type JsonSchemaEchoAnnotations,
   type JsonSchemaType,
   getNormalizedEchoAnnotations,
-} from '../json-schema';
-import { Expando, makeTypeJsonSchemaAnnotation } from '../object';
-import { type JsonSchemaReferenceInfo, Ref, createEchoReferenceSchema } from '../ref';
-
-import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
+} from './json-schema-type';
 
 // TODO(burdon): Are these values stored (can they be changed?)
 export enum PropType {
@@ -71,8 +76,11 @@ export type JsonSchemaOptions = {
 
 /**
  * Convert effect schema to JSON Schema.
+ * NOTE: This handles custom annotations.
  * @param schema
  */
+// TODO(burdon): Reconcile with possibly extending @effect/Schema/JSONSchema
+//  We add additional propertyOrder (but the object properties ARE ordered); and type "string" for literals.
 export const toJsonSchema = (schema: Schema.Schema.All, options: JsonSchemaOptions = {}): JsonSchemaType => {
   assertArgument(Schema.isSchema(schema), 'schema');
   let jsonSchema = _toJsonSchemaAST(schema.ast);
@@ -346,6 +354,7 @@ const refToEffectSchema = (root: any): Schema.Schema.AnyNoContext => {
   if (!('reference' in root)) {
     return Ref(Expando);
   }
+
   const reference: JsonSchemaReferenceInfo = root.reference;
   if (typeof reference !== 'object') {
     throw new Error('Invalid reference field in ref schema');