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

package/src/internal/Entity/api.ts

@@ -3,21 +3,21 @@
 //
 
 import { invariant } from '@dxos/invariant';
-import { type DXN } from '@dxos/keys';
+import { type EID } from '@dxos/keys';
 import { assumeType } from '@dxos/util';
 
 import type { AnyEntity } from '../common/types';
 import { type InternalObjectProps, ObjectDatabaseId } from './model';
-import { getObjectDXN } from './util';
+import { getObjectEchoUri } from './util';
 
 /**
- * Get the DXN of an entity.
+ * Get the canonical EID of an entity.
  * Accepts both reactive entities and snapshots.
  */
-export const getDXN = (entity: AnyEntity): DXN => {
-  const dxn = getObjectDXN(entity);
-  invariant(dxn != null, 'Invalid entity.');
-  return dxn;
+export const getUri = (entity: AnyEntity): EID.EID => {
+  const uri = getObjectEchoUri(entity);
+  invariant(uri != null, 'Invalid entity.');
+  return uri;
 };
 
 /**

package/src/internal/Entity/entity.ts

@@ -3,47 +3,119 @@
 //
 
 import * as Schema from 'effect/Schema';
-import type * as SchemaAST from 'effect/SchemaAST';
+import * as SchemaAST from 'effect/SchemaAST';
 import type * as Types from 'effect/Types';
 
+import { DXN, EntityId } from '@dxos/keys';
 import { type ToMutable } from '@dxos/util';
 
-import { type TypeMeta } from '../Annotation';
-import { type AnyEntity, type EntityKind, SchemaKindId } from '../common/types';
+import { type TypeAnnotation, TypeAnnotationId } from '../Annotation/annotations';
+import { makeTypeJsonSchemaAnnotation } from '../Annotation/util';
+import { defineHiddenProperty } from '../common/proxy/define-hidden-property';
+import { makeObject } from '../common/proxy/make-object';
+import { getProxyTarget } from '../common/proxy/proxy-utils';
+import {
+  type AnyEntity,
+  EntityKind,
+  InstancePhantomId,
+  KindId,
+  SchemaKindId,
+  StaticTypeSchemaSlot,
+} from '../common/types';
+import { type EntityMeta } from '../common/types/meta';
+import { JsonSchemaType } from '../JsonSchema/json-schema-type';
 
 // TODO(burdon): Define Schema type for `typename` and use consistently for all DXN-like properties.
 
 // type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
 export type EchoTypeSchemaProps<T, ExtraFields = {}> = Types.Simplify<AnyEntity & ToMutable<T> & ExtraFields>;
 
+/**
+ * Options accepted by every `Type.makeObject` / `Type.makeRelation` / type-kind
+ * factory. Defaults are derived from `(typename, version)` so callers normally
+ * pass nothing.
+ */
+export type EchoTypeOptions = {
+  /**
+   * Override the entity id stamped on the in-memory `Type.Type` value.
+   *
+   * Defaults to `EntityId.deterministic(typename, version)` — stable across processes
+   * and workerd-safe (no `crypto.getRandomValues()` at module-evaluation time).
+   * Pass an explicit id (typically `EntityId.random()`) to opt out of the
+   * deterministic default.
+   */
+  id?: EntityId;
+};
+
+/**
+ * In-memory `Type.Type` entity shape produced by `Type.makeObject(dxn)` /
+ * `Type.makeRelation({...})`. A live reactive `TypeSchema` instance —
+ * identical to a persisted `Type.Type` except for database attachment.
+ *
+ * NOT a `Schema.Schema`. The underlying Effect Schema is cached on the hidden
+ * `StaticTypeSchemaSlot` slot — retrieve it via `Type.getSchema(...)`.
+ */
 // TODO(burdon): Rename EchoEntitySchema.
 export interface EchoTypeSchema<
   Self extends Schema.Schema.Any,
   ExtraFields = {},
   K extends EntityKind = EntityKind,
   Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
->
-  extends
-    TypeMeta,
-    Schema.AnnotableClass<
-      EchoTypeSchema<Self, ExtraFields, K, Fields>,
-      EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields>,
-      EchoTypeSchemaProps<Schema.Schema.Encoded<Self>, ExtraFields>,
-      Schema.Schema.Context<Self>
-    > {
+> {
   /**
-   * Schema kind key that marks this as an ECHO schema and indicates its kind.
-   * Makes EchoTypeSchema satisfy the Type.AnyObj or Type.Relation.Any type.
+   * Entity-kind brand. Type entities are their own kind (`Type`) regardless of
+   * the kind of instance they describe — `[SchemaKindId]` carries the latter.
+   * This lets predicates like `Obj.isObject` / `Relation.isRelation` cleanly
+   * reject type entities without also having to inspect `[SchemaKindId]`.
    */
+  readonly [KindId]: EntityKind.Type;
+
+  /** Schema-kind brand indicating what kind of instance this type describes. */
   readonly [SchemaKindId]: K;
 
   /**
-   * The fields defined in the original struct schema.
-   * Allows accessing field definitions for introspection.
+   * Entity id. Always present — stamped at construction — but NOT the type's
+   * identity while in-memory: an unattached type resolves its URI to the typename
+   * DXN, switching to `echo:/<id>` only once attached to a database (see
+   * `getTypeURIFromSpecifier`, which discriminates by database attachment).
    */
+  readonly id: EntityId;
+
+  /** Source Effect Schema (kept on a hidden slot for `Type.getSchema`). */
+  readonly [StaticTypeSchemaSlot]: Schema.Schema.AnyNoContext;
+
+  // NOTE: `typename` / `version` are intentionally NOT fields. They live in
+  // `EntityMeta` (`key` / `version`); read via `Type.getTypename(self)` /
+  // `Type.getVersion(self)`.
+  readonly jsonSchema: JsonSchemaType;
+
+  /** Struct fields for introspection. */
   readonly fields: Fields;
 
-  instanceOf(value: unknown): boolean;
+  /** Phantom — instance type produced by `Obj.make(self, ...)`. */
+  readonly _instance?: EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields>;
+
+  /**
+   * Phantom slot mirroring `Type<A>` so internal helpers (`makeObject`,
+   * `createObject`, `Ref.make`) infer the instance type uniformly whether
+   * the caller passes an `EchoTypeSchema` or a top-level `Type.Type` entity.
+   *
+   * Includes the instance-kind brand (`[KindId]`) so the phantom is assignable
+   * to the matching public-side interface in `Type.ts` (`Type.Obj` /
+   * `Type.Relation` / `Type.Type`). Each kind projects identity: instances of
+   * an object-kind schema are object-kind entities, type-kind schemas produce
+   * type-kind (persisted Type.Type) entities — the latter additionally carry
+   * the `[SchemaKindId]` / `[StaticTypeSchemaSlot]` brands the echo-handler
+   * proxy exposes on persisted Type entities.
+   */
+  readonly [InstancePhantomId]?: EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields> & {
+    readonly [KindId]: K;
+  } & (K extends EntityKind.Type
+      ? {
+          readonly [SchemaKindId]: EntityKind.Type;
+          readonly [StaticTypeSchemaSlot]: Schema.Schema.AnyNoContext;
+        }
+      : {});
 }
 
 // type MakeProps =
@@ -77,8 +149,60 @@ export interface EchoTypeSchema<
 // const _getDisableValidationMakeOption = (options: MakeProps | undefined): boolean =>
 //   Predicate.isBoolean(options) ? options : options?.disableValidation ?? false;
 
+/**
+ * Identity (typename + version) of the type meta-schema — the `Type.Type` that
+ * every ECHO type entity is itself an instance of. Shared by the materialisation
+ * vehicle ({@link persistentEntitySchema}) and `TypeSchema` so the two cannot
+ * drift on identity.
+ */
+export const TypeMetaSchemaDXN = DXN.make('org.dxos.type.schema', '0.1.0');
+
+/**
+ * Effect Schema that every `Type.Type` entity is an instance of: the meta-schema
+ * struct `{ name?, jsonSchema, id }` branded as a type-kind ECHO entity. This is
+ * the materialisation vehicle for `makeObject` below — the canonical user-facing
+ * entity is `Type/type-schema.ts`'s `TypeSchema`, which carries the same shape
+ * plus UI annotations.
+ *
+ * Kept self-contained (no import of `TypeSchema`) to avoid a bootstrap cycle:
+ * `TypeSchema` is itself produced via `makeEchoTypeSchema`, so this builder must
+ * not depend on it. `jsonSchema` is declared optional here (only on the
+ * materialisation vehicle — the canonical `TypeSchema` keeps it required) so the
+ * construction-time `Schema.asserts` does not force the field before it is
+ * attached; it is populated immediately after via a lazy accessor (see
+ * `makeEchoTypeSchema`).
+ */
+// TODO(wittjosiah): Reconcile with `TypeSchema` (`Type/type-schema.ts`).
+//   Both describe the same `org.dxos.type.schema` shape.
+const persistentEntitySchema: Schema.Schema.AnyNoContext = (() => {
+  const typename = DXN.getName(TypeMetaSchemaDXN);
+  const version = DXN.getVersion(TypeMetaSchemaDXN)!;
+  const struct = Schema.Struct({
+    name: Schema.optional(Schema.String),
+    jsonSchema: JsonSchemaType.pipe(Schema.optional),
+    id: EntityId,
+  });
+  const ast = SchemaAST.annotations(struct.ast, {
+    [TypeAnnotationId]: { kind: EntityKind.Type, typename, version } satisfies TypeAnnotation,
+    [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({ kind: EntityKind.Type, typename, version }),
+  });
+  return Schema.make(ast);
+})();
+
 /**
  * @internal
+ *
+ * Build an in-memory `Type.Type` entity (the value returned by `Type.makeObject`
+ * / `Type.makeRelation`). The result is a LIVE reactive `TypeSchema`
+ * instance — identical in every respect to a persisted `Type.Type` except that
+ * it is not yet attached to a database. It is mutable via `Type.update`, can be
+ * passed to `db.add(...)` (which keeps the same proxy and swaps the handler),
+ * and round-trips through `jsonSchema`.
+ *
+ * The source Effect Schema describing the user's type is cached on
+ * `[StaticTypeSchemaSlot]` so `Type.getSchema(...)` returns it without a
+ * jsonSchema round-trip; the cache is invalidated by the proxy set-trap when
+ * `jsonSchema` is mutated (see `typed-handler.ts`).
  */
 export const makeEchoTypeSchema = <
   Self extends Schema.Schema.Any,
@@ -91,38 +215,63 @@ export const makeEchoTypeSchema = <
   typename: string,
   version: string,
   kind: K,
+  computeJsonSchema: () => JsonSchemaType,
+  explicitId?: EntityId,
 ): EchoTypeSchema<Self, {}, K, Fields> => {
-  return class EchoObjectSchemaClass extends Schema.make<
+  // Source Effect Schema describing the user's type — cached for `Type.getSchema`.
+  const sourceSchema = Schema.make<
     EchoTypeSchemaProps<Schema.Schema.Type<Self>>,
     EchoTypeSchemaProps<Schema.Schema.Encoded<Self>>,
     Schema.Schema.Context<Self>
-  >(ast) {
-    static readonly typename = typename;
-    static readonly version = version;
-    static readonly [SchemaKindId] = kind;
-    static readonly fields = fields;
-
-    static override annotations(
-      annotations: Schema.Annotations.GenericSchema<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>,
-    ): EchoTypeSchema<Self, {}, K, Fields> {
-      const schema = Schema.make<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>(ast).annotations(annotations);
-      return makeEchoTypeSchema<Self, K, Fields>(fields, schema.ast, typename, version, kind);
-    }
-
-    // static make(
-    //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
-    //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
-    //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
-    //   options?: MakeProps,
-    // ): Simplify<Schema.TypeLiteral.Type<Fields, []>> {
-    //   const propsWithDefaults: any = _lazilyMergeDefaults(fields, { ...(props as any) });
-    //   return _getDisableValidationMakeOption(options)
-    //     ? propsWithDefaults
-    //     : ParseResult.validateSync(this)(propsWithDefaults);
-    // }
-
-    static instanceOf(value: unknown): boolean {
-      return Schema.is(this)(value);
-    }
-  };
+  >(ast);
+
+  // `typename` / `version` route through `EntityMeta` (`key` / `version`) — the
+  // canonical registry-provenance pair — not data fields. `keys` is empty for
+  // in-memory declarations until persisted.
+  const meta: Partial<EntityMeta> = { keys: [], key: typename, version };
+
+  // Default to a deterministic id derived from `(typename, version)` so that
+  // constructing a `Type.Type` entity never reaches `crypto.getRandomValues()`.
+  // Cloudflare workerd forbids RNG calls in global scope, and the ~hundreds of
+  // `Type.makeObject(...)` call sites across the monorepo execute at module top.
+  // `setIdOnTarget` (see `proxy/make-object.ts`) short-circuits on a pre-supplied
+  // valid id, so this also bypasses the `EntityId.random()` path inside `makeObject`.
+  // Callers can override via `Type.makeObject(dxn, { id })` when they want a fresh
+  // random id (e.g. inside a request handler where workerd does allow RNG).
+  const id = explicitId ?? EntityId.deterministic(typename, version);
+
+  // Materialise as a live reactive meta-schema instance. `jsonSchema` is attached
+  // below as a getter (not passed here as data) for two reasons; see that accessor.
+  const entity = makeObject(persistentEntitySchema, { id } as any, meta);
+
+  const target = getProxyTarget(entity)!;
+  // `jsonSchema` is always available, but computed once on first read rather than at
+  // construction: serializing the AST walks `Schema.suspend(...)` thunks, and for a
+  // self-referential type (`Schema.suspend(() => Self)`) that thunk hits `Self`'s TDZ
+  // while we're still inside its `const` initializer. A getter also lets reads return
+  // the raw object instead of a child reactive proxy.
+  let memoizedJsonSchema: JsonSchemaType | undefined;
+  Object.defineProperty(target, 'jsonSchema', {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return (memoizedJsonSchema ??= computeJsonSchema());
+    },
+    set(value: JsonSchemaType) {
+      memoizedJsonSchema = value;
+    },
+  });
+  // Cache the source Effect Schema (read by `Type.getSchema` via the proxy's
+  // `[StaticTypeSchemaSlot]` get-trap; invalidated on `jsonSchema` mutation).
+  defineHiddenProperty(target, StaticTypeSchemaSlot, sourceSchema);
+  // Schema-kind brand: what kind of instance this type describes. There is no
+  // database handler to derive it for in-memory entities, so stamp it directly.
+  defineHiddenProperty(target, SchemaKindId, kind);
+  // Struct fields for introspection. A getter (not a data property) so reads return
+  // the raw fields object rather than a child reactive proxy.
+  Object.defineProperty(target, 'fields', { configurable: true, enumerable: false, get: () => fields });
+
+  return entity as unknown as EchoTypeSchema<Self, {}, K, Fields>;
 };
+
+export { isEntity } from './guard';

package/src/internal/Entity/guard.ts

@@ -0,0 +1,26 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as Entity from '../../Entity';
+import { KindId, SnapshotKindId } from '../common/types';
+
+/**
+ * Returns true if the value is an ECHO entity instance (object or relation).
+ */
+export const isEntity = (value: unknown): value is Entity.Unknown => {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  return (value as any)[KindId] !== undefined;
+};
+
+/**
+ * Returns true if the value is an ECHO entity snapshot.
+ */
+export const isSnapshot = (value: unknown): value is Entity.Snapshot => {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  return (value as any)[SnapshotKindId] !== undefined;
+};

package/src/internal/Entity/index.ts

@@ -7,5 +7,7 @@ export * from './entity';
 export * from './model'; // TODO(burdon): Rename.
 export * from './object';
 export * from './relation';
+export * from './type-kind';
+export * from './type-uri';
 export * from './util';
 export * from './version';

package/src/internal/Entity/model.ts

@@ -6,24 +6,22 @@ import type * as Schema from 'effect/Schema';
 
 import { type ForeignKey } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
-import { DXN, ObjectId } from '@dxos/keys';
+import { EID, EntityId, type URI } from '@dxos/keys';
 import { assumeType } from '@dxos/util';
 
 import type * as Database from '../../Database';
 import {
-  type ATTR_META,
   type ATTR_PARENT,
   type ATTR_TYPE,
   ATTR_DELETED,
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
-  ATTR_SELF_DXN,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
   EntityKind,
   KindId,
-  type MetaId,
   ObjectDatabaseId,
   ObjectDeletedId,
-  type ObjectMeta,
   ObjectVersionId,
   type ParentId,
   RelationSourceDXNId,
@@ -31,12 +29,21 @@ import {
   RelationTargetDXNId,
   RelationTargetId,
   type SchemaId,
-  SelfDXNId,
+  SelfURIId,
   TypeId,
   type Version,
 } from '../common/types';
+import { type ATTR_META, type MetaId, type EntityMeta } from '../common/types/meta';
 
-export { ATTR_DELETED, ATTR_SELF_DXN, ObjectDatabaseId, ObjectDeletedId, ObjectVersionId, SelfDXNId };
+export {
+  ATTR_DELETED,
+  ATTR_SELF_URI,
+  ATTR_SELF_URI_LEGACY,
+  ObjectDatabaseId,
+  ObjectDeletedId,
+  ObjectVersionId,
+  SelfURIId,
+};
 
 /**
  * Internal runtime representation of an object.
@@ -44,18 +51,18 @@ export { ATTR_DELETED, ATTR_SELF_DXN, ObjectDatabaseId, ObjectDeletedId, ObjectV
  */
 // NOTE: Each symbol has a jsdoc describing its purpose.
 export interface InternalObjectProps {
-  readonly id: ObjectId;
-  readonly [SelfDXNId]: DXN;
+  readonly id: EntityId;
+  readonly [SelfURIId]: EID.EID;
   readonly [KindId]: EntityKind;
   readonly [SchemaId]: Schema.Schema.AnyNoContext;
-  readonly [TypeId]: DXN;
-  readonly [MetaId]?: ObjectMeta;
+  readonly [TypeId]: URI.URI;
+  readonly [MetaId]?: EntityMeta;
   [ParentId]?: InternalObjectProps;
   readonly [ObjectDatabaseId]?: Database.Database;
   readonly [ObjectDeletedId]?: boolean;
   readonly [ObjectVersionId]?: Version;
-  readonly [RelationSourceDXNId]?: DXN;
-  readonly [RelationTargetDXNId]?: DXN;
+  readonly [RelationSourceDXNId]?: EID.EID;
+  readonly [RelationTargetDXNId]?: EID.EID;
   readonly [RelationSourceId]?: InternalObjectProps;
   readonly [RelationTargetId]?: InternalObjectProps;
 }
@@ -63,7 +70,7 @@ export interface InternalObjectProps {
 /**
  * Entity metadata.
  */
-export interface ObjectMetaJSON {
+export interface EntityMetaJSON {
   keys: ForeignKey[];
   tags?: string[];
   key?: string;
@@ -74,14 +81,14 @@ export interface ObjectMetaJSON {
  * JSON representation of an object or relation metadata.
  */
 export interface ObjectJSON {
-  id: string;
-  [ATTR_TYPE]: DXN.String;
-  [ATTR_SELF_DXN]?: DXN.String;
-  [ATTR_PARENT]?: string; // Encoded reference
+  id: EntityId;
+  [ATTR_TYPE]?: URI.URI;
+  [ATTR_SELF_URI]?: EID.EID;
+  [ATTR_PARENT]?: EID.EID; // Encoded reference
   [ATTR_DELETED]?: boolean;
-  [ATTR_META]?: ObjectMetaJSON;
-  [ATTR_RELATION_SOURCE]?: DXN.String;
-  [ATTR_RELATION_TARGET]?: DXN.String;
+  [ATTR_META]?: EntityMetaJSON;
+  [ATTR_RELATION_SOURCE]?: EID.EID;
+  [ATTR_RELATION_TARGET]?: EID.EID;
 
   /**
    * Application-specific properties.
@@ -95,17 +102,17 @@ export interface ObjectJSON {
 export function assertObjectModel(obj: unknown): asserts obj is InternalObjectProps {
   invariant(typeof obj === 'object' && obj !== null, 'Invalid object model: not an object');
   assumeType<InternalObjectProps>(obj);
-  invariant(ObjectId.isValid(obj.id), 'Invalid object model: invalid id');
-  invariant(obj[TypeId] === undefined || obj[TypeId] instanceof DXN, 'Invalid object model: invalid type');
+  invariant(EntityId.isValid(obj.id), 'Invalid object model: invalid id');
+  invariant(obj[TypeId] === undefined || typeof obj[TypeId] === 'string', 'Invalid object model: invalid type');
   invariant(
-    obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation,
+    obj[KindId] === EntityKind.Object || obj[KindId] === EntityKind.Relation || obj[KindId] === EntityKind.Type,
     'Invalid object model: invalid entity kind',
   );
 
   if (obj[KindId] === EntityKind.Relation) {
-    invariant(obj[RelationSourceDXNId] instanceof DXN, 'Invalid object model: invalid relation source');
-    invariant(obj[RelationTargetDXNId] instanceof DXN, 'Invalid object model: invalid relation target');
-    invariant(!(obj[RelationSourceId] instanceof DXN), 'Invalid object model: source pointer is a DXN');
-    invariant(!(obj[RelationTargetId] instanceof DXN), 'Invalid object model: target pointer is a DXN');
+    invariant(EID.isEID(obj[RelationSourceDXNId]), 'Invalid object model: invalid relation source');
+    invariant(EID.isEID(obj[RelationTargetDXNId]), 'Invalid object model: invalid relation target');
+    invariant(!EID.isEID(obj[RelationSourceId]), 'Invalid object model: source pointer is a DXN');
+    invariant(!EID.isEID(obj[RelationTargetId]), 'Invalid object model: target pointer is a DXN');
   }
 }

package/src/internal/Entity/object.ts

@@ -6,10 +6,13 @@ import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
 import { invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
 
-import { type TypeAnnotation, TypeAnnotationId, type TypeMeta, makeTypeJsonSchemaAnnotation } from '../Annotation';
+import { type TypeAnnotation, TypeAnnotationId } from '../Annotation/annotations';
+import { makeTypeJsonSchemaAnnotation } from '../Annotation/util';
 import { EntityKind } from '../common/types';
-import { type EchoTypeSchema, makeEchoTypeSchema } from './entity';
+import { toJsonSchema } from '../JsonSchema';
+import { type EchoTypeOptions, type EchoTypeSchema, makeEchoTypeSchema } from './entity';
 
 /**
  * Object schema type with kind marker.
@@ -25,11 +28,16 @@ export type EchoObjectSchema<
  */
 export const EchoObjectSchema: {
   (
-    meta: TypeMeta,
+    dxn: DXN.DXN,
+    options?: EchoTypeOptions,
   ): <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
     self: Self & { fields?: Fields },
   ) => EchoObjectSchema<Self, Fields>;
-} = ({ typename, version }) => {
+} = (dxn, options) => {
+  const typename = DXN.getName(dxn);
+  const version = DXN.getVersion(dxn);
+  invariant(version, `Type.makeObject requires a versioned DXN: ${dxn}`);
+
   return <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
     self: Self & { fields?: Fields },
   ): EchoObjectSchema<Self, Fields> => {
@@ -52,6 +60,14 @@ export const EchoObjectSchema: {
       }),
     });
 
-    return makeEchoTypeSchema<Self, EntityKind.Object, Fields>(fields, ast, typename, version, EntityKind.Object);
+    return makeEchoTypeSchema<Self, EntityKind.Object, Fields>(
+      fields,
+      ast,
+      typename,
+      version,
+      EntityKind.Object,
+      () => toJsonSchema(Schema.make(ast)),
+      options?.id,
+    );
   };
 };