@dxos/echo 0.8.4-main.d05539e30a → 0.8.4-main.d9fc60f731

package/src/internal/JsonSchema/json-schema.test.ts

@@ -8,7 +8,7 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { describe, expect, test } from 'vitest';
 
 import { type JsonProp, findAnnotation } from '@dxos/effect';
-import { ObjectId } from '@dxos/keys';
+import { DXN, EntityId } from '@dxos/keys';
 import { log } from '@dxos/log';
 
 import { TestSchema, prepareAstForCompare } from '../../testing';
@@ -26,7 +26,7 @@ import { EchoObjectSchema } from '../Entity';
 import { Email, FormatAnnotation, TypeFormat } from '../Format';
 import { JsonSchemaType, getNormalizedEchoAnnotations, getSchemaProperty, setSchemaProperty } from '../JsonSchema';
 import { Ref, createSchemaReference, getReferenceAst, getSchemaReference } from '../Ref';
-import { PersistentSchema } from '../Type';
+import { TypeSchema } from '../Type';
 import { toEffectSchema, toJsonSchema } from './json-schema';
 
 const EXAMPLE_NAMESPACE = '@example';
@@ -34,26 +34,18 @@ const EXAMPLE_NAMESPACE = '@example';
 describe('effect-to-json', () => {
   test('type annotation', () => {
     const Test = Schema.Struct({ name: Schema.String }).pipe(
-      Type.object({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
+      Type.makeObject(DXN.make('com.example.type.test', '0.1.0')),
     );
     const jsonSchema = toJsonSchema(Test);
-    expect((jsonSchema as any).$id).toEqual('dxn:type:com.example.type.test');
-    expect((jsonSchema as any).version).toEqual('0.1.0');
+    expect(jsonSchema.$id).toEqual('dxn:com.example.type.test:0.1.0');
+    expect(jsonSchema.version).toEqual('0.1.0');
   });
 
   test('property meta annotation', () => {
     const meta = { maxLength: 0 };
     const Test = Schema.Struct({
       name: Schema.String.pipe(PropertyMeta(EXAMPLE_NAMESPACE, meta)),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
     const jsonSchema = toJsonSchema(Test);
     expect(getNormalizedEchoAnnotations(jsonSchema.properties!.name!)!.meta![EXAMPLE_NAMESPACE]).to.deep.eq(meta);
   });
@@ -61,20 +53,10 @@ describe('effect-to-json', () => {
   test('reference annotation', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.testNested',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
     const Test = Schema.Struct({
       name: Ref(Nested),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
     const jsonSchema = toJsonSchema(Test);
     // log.info('schema', { jsonSchema });
     const nested = jsonSchema.properties!.name;
@@ -86,20 +68,10 @@ describe('effect-to-json', () => {
   test.skip('reference annotation with lookup property', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.testNested',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
     const Test = Schema.Struct({
       name: Ref(Nested).annotations({ [FieldLookupAnnotationId]: 'name' }),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
     const jsonSchema = toJsonSchema(Test);
     const effectSchema = toEffectSchema(jsonSchema);
 
@@ -110,20 +82,10 @@ describe('effect-to-json', () => {
   test('array of references', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.testNested',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
     const Test = Schema.Struct({
       name: Schema.Array(Ref(Nested)),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
 
     const jsonSchema = toJsonSchema(Test);
     expectReferenceAnnotation((jsonSchema.properties!.name as any).items);
@@ -132,20 +94,10 @@ describe('effect-to-json', () => {
   test('optional references', () => {
     const Nested = Schema.Struct({
       name: Schema.String,
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.testNested',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.testNested', '0.1.0')));
     const Test = Schema.Struct({
       name: Schema.optional(Ref(Nested)),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.test',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.test', '0.1.0')));
     const jsonSchema = toJsonSchema(Test);
     expectReferenceAnnotation(jsonSchema.properties!.name);
   });
@@ -163,17 +115,12 @@ describe('effect-to-json', () => {
       email: Schema.String.pipe(FormatAnnotation.set(TypeFormat.Email)).annotations({
         description: 'Email address',
       }),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.person',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
 
     const jsonSchema = toJsonSchema(TempSchema);
     expect(jsonSchema).to.deep.eq({
       $schema: 'http://json-schema.org/draft-07/schema#',
-      $id: 'dxn:type:com.example.type.person',
+      $id: 'dxn:com.example.type.person:0.1.0',
 
       entityKind: EntityKind.Object,
       typename: 'com.example.type.person',
@@ -214,29 +161,19 @@ describe('effect-to-json', () => {
   test('reference property by ref', () => {
     const Organization = Schema.Struct({
       field: Schema.String,
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.organization',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
 
     const Contact = Schema.Struct({
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.person',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
 
     // log.info('Contact', { ast: Contact.ast });
 
     const jsonSchema = toJsonSchema(Contact);
     expect(jsonSchema).toEqual({
       $schema: 'http://json-schema.org/draft-07/schema#',
-      $id: 'dxn:type:com.example.type.person',
+      $id: 'dxn:com.example.type.person:0.1.0',
 
       entityKind: EntityKind.Object,
       typename: 'com.example.type.person',
@@ -259,7 +196,7 @@ describe('effect-to-json', () => {
               $ref: '/schemas/echo/ref',
               reference: {
                 schema: {
-                  $ref: 'dxn:type:com.example.type.organization',
+                  $ref: 'dxn:com.example.type.organization',
                 },
                 schemaVersion: '0.1.0',
               },
@@ -276,31 +213,21 @@ describe('effect-to-json', () => {
   test('add reference property', () => {
     const Organization = Schema.Struct({
       field: Schema.String,
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.organization',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
 
     const Contact = Schema.Struct({
       name: Schema.String,
       organization: Ref(Organization).annotations({ description: 'Contact organization' }),
-    }).pipe(
-      Type.object({
-        typename: 'com.example.type.person',
-        version: '0.1.0',
-      }),
-    );
+    }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
 
     const jsonSchema = toJsonSchema(Contact);
-    setSchemaProperty(jsonSchema, 'organization' as JsonProp, createSchemaReference(Organization.typename));
+    setSchemaProperty(jsonSchema, 'organization' as JsonProp, createSchemaReference(Type.getTypename(Organization)));
     const { typename } = getSchemaReference(getSchemaProperty(jsonSchema, 'organization' as JsonProp) ?? {}) ?? {};
-    expect(typename).to.eq(Organization.typename);
+    expect(typename).to.eq(Type.getTypename(Organization));
   });
 
-  test('serialize circular schema (PersistentSchema)', () => {
-    const jsonSchema = toJsonSchema(PersistentSchema);
+  test('serialize circular schema (TypeSchema)', () => {
+    const jsonSchema = toJsonSchema(TypeSchema);
     expect(Object.keys(jsonSchema.properties!).length).toBeGreaterThan(0);
 
     // TODO(dmaretskyi): Currently unable to deserialize.
@@ -349,18 +276,18 @@ describe('effect-to-json', () => {
     const schema = TestSchema.EmployedBy;
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toEqual({
-      $id: 'dxn:type:com.example.type.employed-by',
+      $id: 'dxn:com.example.type.employedBy:0.1.0',
       $schema: 'http://json-schema.org/draft-07/schema#',
       entityKind: 'relation',
-      typename: 'com.example.type.employed-by',
+      typename: 'com.example.type.employedBy',
       version: '0.1.0',
       relationSource: {
         // TODO(dmaretskyi): Should those point to specific schema version?
-        $ref: 'dxn:type:com.example.type.person',
+        $ref: 'dxn:com.example.type.person',
       },
       relationTarget: {
         // TODO(dmaretskyi): Should those point to specific schema version?
-        $ref: 'dxn:type:com.example.type.organization',
+        $ref: 'dxn:com.example.type.organization',
       },
       type: 'object',
       properties: {
@@ -382,19 +309,13 @@ describe('effect-to-json', () => {
 
   test('label prop', () => {
     const Organization = Schema.Struct({
-      id: ObjectId,
+      id: EntityId,
       name: Schema.String,
-    }).pipe(
-      EchoObjectSchema({
-        typename: 'com.example.type.organization',
-        version: '0.1.0',
-      }),
-      LabelAnnotation.set(['name']),
-    );
+    }).pipe(LabelAnnotation.set(['name']), EchoObjectSchema(DXN.make('com.example.type.organization', '0.1.0')));
 
     const jsonSchema = toJsonSchema(Organization);
     expect(jsonSchema).toEqual({
-      $id: 'dxn:type:com.example.type.organization',
+      $id: 'dxn:com.example.type.organization:0.1.0',
       $schema: 'http://json-schema.org/draft-07/schema#',
       typename: 'com.example.type.organization',
       version: '0.1.0',
@@ -421,9 +342,9 @@ describe('effect-to-json', () => {
 
   test('object id with description', () => {
     const schema = Schema.Struct({
-      id: ObjectId.annotations({ description: 'The id' }),
+      id: EntityId.annotations({ description: 'The id' }),
     });
-    // log.info('schema', { schema: ObjectId.ast });
+    // log.info('schema', { schema: EntityId.ast });
     const jsonSchema = toJsonSchema(schema);
     expect(jsonSchema).toMatchInlineSnapshot(`
       {
@@ -467,7 +388,7 @@ describe('effect-to-json', () => {
   const expectReferenceAnnotation = (object: JsonSchemaType) => {
     expect(object.reference).to.deep.eq({
       schema: {
-        $ref: 'dxn:type:com.example.type.testNested',
+        $ref: 'dxn:com.example.type.testNested',
       },
       schemaVersion: '0.1.0',
     });
@@ -494,12 +415,7 @@ describe('json-to-effect', () => {
     test(`deserialized equals original ${partial ? 'with partial' : ''}`, () => {
       const Organization = Schema.Struct({
         field: Schema.String,
-      }).pipe(
-        Type.object({
-          typename: 'com.example.type.organization',
-          version: '0.1.0',
-        }),
-      );
+      }).pipe(Type.makeObject(DXN.make('com.example.type.organization', '0.1.0')));
 
       const fields = {
         string: Schema.String,
@@ -516,10 +432,7 @@ describe('json-to-effect', () => {
       } as const;
 
       const Test = (partial ? Schema.partial(Schema.Struct(fields)) : Schema.Struct(fields)).pipe(
-        Type.object({
-          typename: 'com.example.type.test',
-          version: '0.1.0',
-        }),
+        Type.makeObject(DXN.make('com.example.type.test', '0.1.0')),
       );
 
       const jsonSchema = toJsonSchema(Test);
@@ -527,11 +440,12 @@ describe('json-to-effect', () => {
 
       const schema = toEffectSchema(jsonSchema);
 
-      expect(() => expect(schema.ast).to.deep.eq(Test.ast)).to.throw();
-      expect(() => expect(prepareAstForCompare(Test.ast)).to.deep.eq(Test.ast)).to.throw();
-      expect(() => expect(schema.ast).to.deep.eq(prepareAstForCompare(Test.ast))).to.throw();
+      const testAst = Type.getSchema(Test).ast;
+      expect(() => expect(schema.ast).to.deep.eq(testAst)).to.throw();
+      expect(() => expect(prepareAstForCompare(testAst)).to.deep.eq(testAst)).to.throw();
+      expect(() => expect(schema.ast).to.deep.eq(prepareAstForCompare(testAst))).to.throw();
       // log.info('', { original: prepareAstForCompare(Schema.ast), deserialized: prepareAstForCompare(schema.ast) });
-      expect(prepareAstForCompare(schema.ast)).to.deep.eq(prepareAstForCompare(Test.ast));
+      expect(prepareAstForCompare(schema.ast)).to.deep.eq(prepareAstForCompare(testAst));
 
       // TODO(dmaretskyi): Fix.
       // expect(
@@ -579,7 +493,7 @@ describe('json-to-effect', () => {
       typename: 'com.example.type.project',
       version: '0.1.0',
     });
-    expect(getTypeIdentifierAnnotation(schema)).to.deep.eq('dxn:echo:@:01JERV1HQCQZDQ4NVCJ42QB38F');
+    expect(getTypeIdentifierAnnotation(schema)).to.deep.eq('echo:/01JERV1HQCQZDQ4NVCJ42QB38F');
   });
 
   test('symbol annotations get compared', () => {
@@ -602,7 +516,7 @@ describe('json-to-effect', () => {
     const schema = TestSchema.HasManager;
     const jsonSchema = toJsonSchema(schema);
     const effectSchema = toEffectSchema(jsonSchema);
-    expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(schema.ast));
+    expect(prepareAstForCompare(effectSchema.ast)).to.deep.eq(prepareAstForCompare(Type.getSchema(schema).ast));
   });
 
   test('generator annotation', () => {
@@ -714,7 +628,7 @@ describe('json-to-effect', () => {
             "$ref": "/schemas/echo/ref",
             "reference": {
               "schema": {
-                "$ref": "dxn:type:com.example.type.person",
+                "$ref": "dxn:com.example.type.person",
               },
               "schemaVersion": "0.1.0",
             },
@@ -735,9 +649,9 @@ describe('json-to-effect', () => {
   test('object nested inside another struct', () => {
     const Contact = Schema.Struct({
       name: Schema.String,
-    }).pipe(EchoObjectSchema({ typename: 'com.example.type.person', version: '0.1.0' }));
+    }).pipe(EchoObjectSchema(DXN.make('com.example.type.person', '0.1.0')));
     const input = Schema.Struct({
-      contact: Contact,
+      contact: Type.getSchema(Contact),
     });
     const jsonSchema = toJsonSchema(input);
     expect(jsonSchema).toMatchInlineSnapshot(`
@@ -746,7 +660,7 @@ describe('json-to-effect', () => {
         "additionalProperties": false,
         "properties": {
           "contact": {
-            "$id": "dxn:type:com.example.type.person",
+            "$id": "dxn:com.example.type.person:0.1.0",
             "additionalProperties": false,
             "entityKind": "object",
             "properties": {
@@ -795,7 +709,7 @@ describe('reference', () => {
       $schema: 'http://json-schema.org/draft-07/schema#',
       reference: {
         schema: {
-          $ref: 'dxn:type:com.example.type.person',
+          $ref: 'dxn:com.example.type.person',
         },
         schemaVersion: '0.1.0',
       },
@@ -813,7 +727,7 @@ describe('reference', () => {
           $ref: '/schemas/echo/ref',
           reference: {
             schema: {
-              $ref: 'dxn:type:com.example.type.person',
+              $ref: 'dxn:com.example.type.person',
             },
             schemaVersion: '0.1.0',
           },
@@ -834,7 +748,7 @@ describe('reference', () => {
           $ref: '/schemas/echo/ref',
           reference: {
             schema: {
-              $ref: 'dxn:type:com.example.type.person',
+              $ref: 'dxn:com.example.type.person',
             },
             schemaVersion: '0.1.0',
           },
@@ -853,8 +767,8 @@ describe('reference', () => {
     const deserializedSchema = toEffectSchema(jsonSchema);
     const refAst = getReferenceAst(deserializedSchema.ast);
     expect(refAst).toEqual({
-      typename: TestSchema.Person.typename,
-      version: TestSchema.Person.version,
+      typename: Type.getTypename(TestSchema.Person),
+      version: Type.getVersion(TestSchema.Person),
     });
   });
 });

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

@@ -13,17 +13,20 @@ import type * as Types from 'effect/Types';
 import { raise } from '@dxos/debug';
 import { mapAst } from '@dxos/effect';
 import { assertArgument, invariant } from '@dxos/invariant';
-import { DXN, ObjectId } from '@dxos/keys';
+import { DXN, EID, EntityId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { clearUndefined, orderKeys, removeProperties } from '@dxos/util';
 
+import type * as Type from '../../Type';
+import { type TypeAnnotation, TypeAnnotationId, TypeIdentifierAnnotationId } from '../Annotation/annotations';
+import { makeTypeJsonSchemaAnnotation } from '../Annotation/util';
 import {
-  type TypeAnnotation,
-  TypeAnnotationId,
-  TypeIdentifierAnnotationId,
-  makeTypeJsonSchemaAnnotation,
-} from '../Annotation';
-import { ANY_OBJECT_TYPENAME, ANY_OBJECT_VERSION, EntityKind, EntityKindSchema } from '../common/types';
+  ANY_OBJECT_TYPENAME,
+  ANY_OBJECT_VERSION,
+  EntityKind,
+  EntityKindSchema,
+  getStaticTypeSchema,
+} from '../common/types';
 import { type JsonSchemaReferenceInfo, createEchoReferenceSchema } from '../Ref';
 import { CustomAnnotations, DecodedAnnotations, EchoAnnotations } from './annotations';
 import {
@@ -81,11 +84,22 @@ export type JsonSchemaOptions = {
 //  We add additional propertyOrder (but the object properties ARE ordered); and type "string" for literals.
 // TODO(wittjosiah): This is mutable because its a pojo, perhaps should be left as readonly at type level though?
 export const toJsonSchema = (
-  schema: Schema.Schema.All,
+  schema: Schema.Schema.All | Type.AnyEntity,
   options: JsonSchemaOptions = {},
 ): Types.DeepMutable<JsonSchemaType> => {
+  // Allow passing a `Type.Type` entity — use its hidden source schema (or its
+  // already-built jsonSchema as a fallback).
+  const slot = getStaticTypeSchema(schema);
+  if (slot != null) {
+    schema = slot;
+  } else if (!Schema.isSchema(schema)) {
+    const entityJsonSchema = (schema as { jsonSchema?: JsonSchemaType }).jsonSchema;
+    if (entityJsonSchema != null) {
+      return entityJsonSchema as Types.DeepMutable<JsonSchemaType>;
+    }
+  }
   assertArgument(Schema.isSchema(schema), 'schema');
-  let jsonSchema = _toJsonSchemaAST(schema.ast);
+  let jsonSchema = _toJsonSchemaAST((schema as Schema.Schema.All).ast);
   if (options.strict) {
     // TOOD(burdon): Workaround to ensure JSON schema is valid (for agv parsing).
     jsonSchema = removeProperties(jsonSchema, (key, value) => {
@@ -340,9 +354,9 @@ const anyToEffectSchema = (root: JSONSchema.JsonSchema7Any): Schema.Schema.AnyNo
   const echoRefinement: JsonSchemaEchoAnnotations = (root as any)[ECHO_ANNOTATIONS_NS_DEPRECATED_KEY];
   // TODO(dmaretskyi): Is this branch still taken?
   if ((echoRefinement as any)?.reference != null) {
-    const echoId = root.$id.startsWith('dxn:echo:') ? root.$id : undefined;
+    const echoUri = root.$id.startsWith('echo:') || root.$id.startsWith('dxn:echo:') ? root.$id : undefined;
     return createEchoReferenceSchema(
-      echoId,
+      echoUri,
       (echoRefinement as any).reference.typename,
       (echoRefinement as any).reference.version,
     );
@@ -363,14 +377,11 @@ const refToEffectSchema = (root: any): Schema.Schema.AnyNoContext => {
     throw new Error('Invalid reference field in ref schema');
   }
 
-  const targetSchemaDXN = DXN.parse(reference.schema.$ref);
-  invariant(targetSchemaDXN.kind === DXN.kind.TYPE);
+  const ref = reference.schema.$ref;
+  const targetSchemaDXN = DXN.tryMake(ref);
+  invariant(targetSchemaDXN, `Expected a type DXN, got: ${ref}`);
 
-  return createEchoReferenceSchema(
-    targetSchemaDXN.toString(),
-    targetSchemaDXN.kind === DXN.kind.TYPE ? targetSchemaDXN.parts[0] : undefined,
-    reference.schemaVersion,
-  );
+  return createEchoReferenceSchema(ref, DXN.getName(targetSchemaDXN), reference.schemaVersion);
 };
 
 //
@@ -391,10 +402,11 @@ const annotations_toJsonSchemaFields = (annotations: SchemaAST.Annotations): Rec
     schemaFields[ECHO_ANNOTATIONS_NS_KEY] = echoAnnotations;
   }
 
+  // For stored schemas the storage URI is the definitive identifier — it overrides
+  // the typename `$id` written above.
   const echoIdentifier = annotations[TypeIdentifierAnnotationId];
   if (echoIdentifier) {
-    schemaFields[ECHO_ANNOTATIONS_NS_KEY] ??= {};
-    schemaFields[ECHO_ANNOTATIONS_NS_KEY].schemaId = echoIdentifier;
+    schemaFields.$id = echoIdentifier;
   }
 
   // Custom (at end).
@@ -409,14 +421,14 @@ const annotations_toJsonSchemaFields = (annotations: SchemaAST.Annotations): Rec
 };
 
 const decodeTypeIdentifierAnnotation = (schema: JsonSchemaType): string | undefined => {
-  // Limit to dxn:echo: URIs.
-  if (schema.$id && schema.$id.startsWith('dxn:echo:')) {
+  // For stored schemas `$id` IS the storage URI (echo:/… or legacy dxn:echo:…).
+  if (schema.$id && (schema.$id.startsWith('echo:') || schema.$id.startsWith('dxn:echo:'))) {
     return schema.$id;
-  } else if (schema.$id && schema.$id.startsWith('dxn:type:') && schema?.echo?.type?.schemaId) {
-    const id = schema?.echo?.type?.schemaId;
-    if (ObjectId.isValid(id)) {
-      return DXN.fromLocalObjectId(id).toString();
-    }
+  }
+  // Legacy: older serializations stored the EID on echo.type.schemaId.
+  const legacySchemaId = schema.echo?.type?.schemaId;
+  if (legacySchemaId) {
+    return EntityId.isValid(legacySchemaId) ? EID.make({ entityId: legacySchemaId }) : legacySchemaId;
   }
   return undefined;
 };
@@ -433,8 +445,8 @@ const decodeTypeAnnotation = (schema: JsonSchemaType): TypeAnnotation | undefine
     if (annotation.kind === EntityKind.Relation) {
       const source = schema.relationSource?.$ref ?? raise(new Error('Relation source not set'));
       const target = schema.relationTarget?.$ref ?? raise(new Error('Relation target not set'));
-      annotation.sourceSchema = DXN.parse(source).toString();
-      annotation.targetSchema = DXN.parse(target).toString();
+      annotation.sourceSchema = DXN.tryMake(source) ?? raise(new Error(`Invalid relation source: ${source}`));
+      annotation.targetSchema = DXN.tryMake(target) ?? raise(new Error(`Invalid relation target: ${target}`));
     }
 
     return annotation;
@@ -470,7 +482,9 @@ const jsonSchemaFieldsToAnnotations = (schema: JsonSchemaType): SchemaAST.Annota
   if (typeAnnotation) {
     annotations[TypeAnnotationId] = typeAnnotation;
     annotations[SchemaAST.JSONSchemaAnnotationId] = makeTypeJsonSchemaAnnotation({
-      identifier: typeIdentifier,
+      // $id is the typename DXN — the schema's type identity. The storage EID (if any)
+      // is preserved separately on TypeIdentifierAnnotation / echo.schemaId.
+      identifier: DXN.make(typeAnnotation.typename, typeAnnotation.version),
       kind: typeAnnotation.kind,
       typename: typeAnnotation.typename,
       version: typeAnnotation.version,

package/src/internal/Obj/clone.ts

@@ -7,7 +7,8 @@ import { deepMapValues } from '@dxos/util';
 
 import type * as Obj from '../../Obj';
 import { makeObject } from '../common/proxy';
-import { getMeta, getSchema } from '../common/types';
+import { getSchema, getStaticTypeSchema, getType } from '../common/types';
+import { getMeta } from '../common/types/meta';
 import { Ref } from '../Ref';
 
 /**
@@ -17,8 +18,12 @@ import { Ref } from '../Ref';
  */
 export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T => {
   const { id, ...data } = obj;
-  const schema = getSchema(obj);
-  invariant(schema != null, 'Object should have a schema');
+  // Prefer cloning through the type entity so the cloned instance preserves
+  // `Obj.getType` identity. Falls back to the raw schema for older instances
+  // that don't have a type-entity back-reference set (e.g. deserialized).
+  const typeEntity = getType(obj);
+  const schema = typeEntity != null ? getStaticTypeSchema(typeEntity) : getSchema(obj);
+  invariant(schema != null, 'Object should have a type or schema');
   const props: any = deepMapValues(data, (value, recurse) => {
     if (Ref.isRef(value)) {
       if (opts?.deep) {
@@ -44,5 +49,5 @@ export const clone = <T extends Obj.Any>(obj: T, opts?: Obj.CloneOptions): T =>
     return recurse(value);
   });
 
-  return makeObject(schema, props, meta);
+  return makeObject(schema, props, meta, typeEntity as object | undefined);
 };

package/src/internal/Obj/create-object.test.ts

@@ -6,13 +6,15 @@ import * as Schema from 'effect/Schema';
 import { inspect } from 'util';
 import { describe, expect, test } from 'vitest';
 
-import { DXN } from '@dxos/keys';
+import { DXN, EID } from '@dxos/keys';
 
 import { Relation } from '../../index';
 import { TestSchema } from '../../testing';
-import { getSchemaDXN, getTypeDXN, isInstanceOf } from '../Annotation';
-import { ATTR_META, ATTR_TYPE, getSchema } from '../common/types';
-import { ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET } from '../Entity';
+import * as Type from '../../Type';
+import { getTypeURI } from '../Annotation';
+import { ATTR_TYPE, getSchema } from '../common/types';
+import { ATTR_META } from '../common/types/meta';
+import { ATTR_RELATION_SOURCE, ATTR_RELATION_TARGET, isInstanceOf } from '../Entity';
 import { createObject } from './create-object';
 import { objectToJSON } from './json-serializer';
 
@@ -40,7 +42,7 @@ describe('create (static version)', () => {
     expect(contact.name).toBe('Bot');
     expect(contact.email).toBe('bot@example.com');
     expect((contact as any)['@type']).toBeUndefined();
-    expect(getTypeDXN(contact)?.toString()).toBe(getSchemaDXN(TestSchema.Person)!.toString());
+    expect(getTypeURI(contact)?.toString()).toBe(Type.getURI(TestSchema.Person).toString());
     expect(isInstanceOf(TestSchema.Person, contact)).toBe(true);
   });
 
@@ -53,7 +55,7 @@ describe('create (static version)', () => {
     const json = JSON.parse(JSON.stringify(contact));
     expect(json).toEqual({
       id: contact.id,
-      '@type': DXN.fromTypenameAndVersion(TestSchema.Person.typename, TestSchema.Person.version).toString(),
+      '@type': DXN.make(Type.getTypename(TestSchema.Person), Type.getVersion(TestSchema.Person)),
       '@meta': {
         keys: [],
       },
@@ -81,9 +83,9 @@ describe('create (static version)', () => {
     const json = JSON.parse(JSON.stringify(manager));
     expect(json).toEqual({
       id: manager.id,
-      [ATTR_TYPE]: DXN.fromTypenameAndVersion(TestSchema.HasManager.typename, TestSchema.HasManager.version).toString(),
-      [ATTR_RELATION_SOURCE]: DXN.fromLocalObjectId(person1.id).toString(),
-      [ATTR_RELATION_TARGET]: DXN.fromLocalObjectId(person2.id).toString(),
+      [ATTR_TYPE]: DXN.make(Type.getTypename(TestSchema.HasManager), Type.getVersion(TestSchema.HasManager)),
+      [ATTR_RELATION_SOURCE]: EID.make({ entityId: person1.id }),
+      [ATTR_RELATION_TARGET]: EID.make({ entityId: person2.id }),
       [ATTR_META]: {
         keys: [],
       },
@@ -96,7 +98,7 @@ describe('create (static version)', () => {
       email: 'bot@example.com',
     });
 
-    expect(getSchema(contact)).toBe(TestSchema.Person);
+    expect(getSchema(contact)).toBe(Type.getSchema(TestSchema.Person));
   });
 
   test('inspect', () => {