@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

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,22 @@ import {
   RelationTargetDXNId,
   RelationTargetId,
   type SchemaId,
-  SelfDXNId,
+  SelfURIId,
   TypeId,
   type Version,
 } from '../common/types';
+import { type ATTR_META, type EntityMeta } from '../common/types/meta';
+import { type MetaId } from '../common/types/model-symbols';
 
-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 +52,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,23 +71,25 @@ export interface InternalObjectProps {
 /**
  * Entity metadata.
  */
-export interface ObjectMetaJSON {
+export interface EntityMetaJSON {
   keys: ForeignKey[];
   tags?: string[];
+  key?: string;
+  version?: string;
 }
 
 /**
  * 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.
@@ -93,17 +103,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,
+    );
   };
 };

package/src/internal/Entity/relation.ts

@@ -7,17 +7,20 @@ import * as SchemaAST from 'effect/SchemaAST';
 
 import { raise } from '@dxos/debug';
 import { assertArgument, invariant } from '@dxos/invariant';
-import { DXN } from '@dxos/keys';
+import { DXN, type EntityId } from '@dxos/keys';
 
+// Type-only imports (erased at runtime — no import cycle); `internal` may depend
+// on the top-level `Obj` / `Type` API at the type level only.
+import type * as Obj from '../../Obj';
+import type * as Type from '../../Type';
 import {
   type TypeAnnotation,
   TypeAnnotationId,
-  type TypeMeta,
   getEntityKind,
   getSchemaTypename,
   getTypeIdentifierAnnotation,
-  makeTypeJsonSchemaAnnotation,
-} from '../Annotation';
+} from '../Annotation/annotations';
+import { makeTypeJsonSchemaAnnotation } from '../Annotation/util';
 import {
   ATTR_RELATION_SOURCE,
   ATTR_RELATION_TARGET,
@@ -26,6 +29,8 @@ import {
   RelationSourceId,
   RelationTargetDXNId,
   RelationTargetId,
+  type UnknownTypeSchema,
+  getStaticTypeSchema,
 } from '../common/types';
 
 export {
@@ -37,6 +42,7 @@ export {
   RelationTargetId,
 };
 
+import { toJsonSchema } from '../JsonSchema';
 import { type EchoTypeSchema, makeEchoTypeSchema } from './entity';
 
 /**
@@ -58,55 +64,75 @@ export type RelationSourceTargetRefs<Source = any, Target = any> = {
 export type RelationSource<R> = R extends RelationSourceTargetRefs<infer Source, infer _Target> ? Source : never;
 export type RelationTarget<R> = R extends RelationSourceTargetRefs<infer _Source, infer Target> ? Target : never;
 
-export type EchoRelationSchemaOptions<
-  TSource extends Schema.Schema.AnyNoContext,
-  TTarget extends Schema.Schema.AnyNoContext,
-> = TypeMeta & {
+/**
+ * Accepted relation endpoint: an object-kind `Type.Type` entity (slot-backed)
+ * or the branded `Obj.Unknown` schema. Source/target are constrained to these
+ * — relations only connect object-kind entities.
+ */
+export type RelationEndpoint = Type.AnyObj | UnknownTypeSchema<any, EntityKind.Object>;
+
+/**
+ * Resolves a relation endpoint to the instance type it describes — the source /
+ * target instance recorded on the relation's `RelationSourceTargetRefs`.
+ */
+export type RelationEndpointInstance<S> =
+  S extends UnknownTypeSchema<infer A, any> ? A : S extends Type.AnyObj ? Type.InstanceType<S> : unknown;
+
+export type EchoRelationSchemaOptions<TSource extends RelationEndpoint, TTarget extends RelationEndpoint> = {
+  dxn: DXN.DXN;
   source: TSource;
   target: TTarget;
+  /**
+   * 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).
+   */
+  id?: EntityId;
 };
 
 /**
- * Relation schema type with kind marker.
+ * Relation schema type with kind marker. `SourceInstance` / `TargetInstance`
+ * are the resolved endpoint instance types (see {@link RelationEndpointInstance}).
  */
 export type EchoRelationSchema<
   Self extends Schema.Schema.Any,
-  Source extends Schema.Schema.AnyNoContext,
-  Target extends Schema.Schema.AnyNoContext,
+  SourceInstance extends Obj.Unknown,
+  TargetInstance extends Obj.Unknown,
   Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
-> = EchoTypeSchema<
-  Self,
-  RelationSourceTargetRefs<Schema.Schema.Type<Source>, Schema.Schema.Type<Target>>,
-  EntityKind.Relation,
-  Fields
->;
+> = EchoTypeSchema<Self, RelationSourceTargetRefs<SourceInstance, TargetInstance>, EntityKind.Relation, Fields>;
 
 /**
  * Schema for Relation entity types.
  */
-export const EchoRelationSchema = <
-  Source extends Schema.Schema.AnyNoContext,
-  Target extends Schema.Schema.AnyNoContext,
->({
+export const EchoRelationSchema = <Source extends RelationEndpoint, Target extends RelationEndpoint>({
+  dxn,
   source,
   target,
-  typename,
-  version,
+  id: explicitId,
 }: EchoRelationSchemaOptions<Source, Target>) => {
-  assertArgument(Schema.isSchema(source), 'source');
-  assertArgument(Schema.isSchema(target), 'target');
-  const sourceDXN = getDXNForRelationSchemaRef(source);
-  const targetDXN = getDXNForRelationSchemaRef(target);
-  if (getEntityKind(source) !== EntityKind.Object) {
+  // `source` / `target` are `Type.Type` entities (slot-backed) or the branded
+  // `Obj.Unknown` schema (used directly); resolve each to its Effect Schema for
+  // the schema-side machinery (DXN ref + entity-kind checks).
+  const sourceSchema = source != null ? (getStaticTypeSchema(source) ?? source) : source;
+  const targetSchema = target != null ? (getStaticTypeSchema(target) ?? target) : target;
+  assertArgument(Schema.isSchema(sourceSchema), 'source');
+  assertArgument(Schema.isSchema(targetSchema), 'target');
+  const typename = DXN.getName(dxn);
+  const version = DXN.getVersion(dxn);
+  invariant(version, `Type.makeRelation requires a versioned DXN: ${dxn}`);
+  const sourceDXN = getDXNForRelationSchemaRef(sourceSchema);
+  const targetDXN = getDXNForRelationSchemaRef(targetSchema);
+  if (getEntityKind(sourceSchema) !== EntityKind.Object) {
     raise(new Error('Source schema must be an echo object schema.'));
   }
-  if (getEntityKind(target) !== EntityKind.Object) {
+  if (getEntityKind(targetSchema) !== EntityKind.Object) {
     raise(new Error('Target schema must be an echo object schema.'));
   }
 
   return <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
     self: Self & { fields?: Fields },
-  ): EchoRelationSchema<Self, Source, Target, Fields> => {
+  ): EchoRelationSchema<Self, RelationEndpointInstance<Source>, RelationEndpointInstance<Target>, Fields> => {
     invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
 
     // Extract fields from the schema if available (Struct schemas have .fields).
@@ -134,15 +160,23 @@ export const EchoRelationSchema = <
       }),
     });
 
-    return makeEchoTypeSchema<Self, EntityKind.Relation, Fields>(fields, ast, typename, version, EntityKind.Relation);
+    return makeEchoTypeSchema<Self, EntityKind.Relation, Fields>(
+      fields,
+      ast,
+      typename,
+      version,
+      EntityKind.Relation,
+      () => toJsonSchema(Schema.make(ast)),
+      explicitId,
+    );
   };
 };
 
-const getDXNForRelationSchemaRef = (schema: Schema.Schema.Any): string => {
+export const getDXNForRelationSchemaRef = (schema: Schema.Schema.Any): DXN.DXN => {
   assertArgument(Schema.isSchema(schema), 'schema');
   const identifier = getTypeIdentifierAnnotation(schema);
   if (identifier) {
-    return identifier;
+    return DXN.tryMake(identifier) ?? raise(new Error(`Invalid schema identifier: ${identifier}`));
   }
 
   const typename = getSchemaTypename(schema);
@@ -150,5 +184,5 @@ const getDXNForRelationSchemaRef = (schema: Schema.Schema.Any): string => {
     throw new Error('Schema must have a typename');
   }
 
-  return DXN.fromTypename(typename).toString();
+  return DXN.make(typename);
 };

package/src/internal/Entity/type-kind.ts

@@ -0,0 +1,75 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+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 } from '../Annotation/annotations';
+import { makeTypeJsonSchemaAnnotation } from '../Annotation/util';
+import { EntityKind } from '../common/types';
+import { toJsonSchema } from '../JsonSchema';
+import { type EchoTypeOptions, type EchoTypeSchema, makeEchoTypeSchema } from './entity';
+
+/**
+ * Type-kind schema marker — produced by {@link EchoTypeKindSchema}.
+ *
+ * Distinguishes meta-schemas (entities of `EntityKind.Type`, such as the
+ * built-in `Type.Type` TypeSchema) from object and relation types.
+ */
+export type EchoTypeKindSchema<
+  Self extends Schema.Schema.Any,
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+> = EchoTypeSchema<Self, {}, EntityKind.Type, Fields>;
+
+/**
+ * Pipeable that brands a schema as a type-kind ECHO entity. Mirrors
+ * {@link EchoObjectSchema} / {@link EchoRelationSchema}, but stamps the
+ * resulting entity with `[SchemaKindId]: EntityKind.Type` and a matching
+ * `TypeAnnotation.kind = 'type'` so meta-schemas surface uniformly through
+ * `Type.isTypeKind`, `Filter.type`, etc.
+ */
+export const EchoTypeKindSchema: {
+  (
+    dxn: DXN.DXN,
+    options?: EchoTypeOptions,
+  ): <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
+    self: Self & { fields?: Fields },
+  ) => EchoTypeKindSchema<Self, Fields>;
+} = (dxn, options) => {
+  const typename = DXN.getName(dxn);
+  const version = DXN.getVersion(dxn);
+  invariant(version, `Type-kind schemas require a versioned DXN: ${dxn}`);
+
+  return <Self extends Schema.Schema.Any, Fields extends Schema.Struct.Fields = Schema.Struct.Fields>(
+    self: Self & { fields?: Fields },
+  ): EchoTypeKindSchema<Self, Fields> => {
+    invariant(SchemaAST.isTypeLiteral(self.ast), 'Schema must be a TypeLiteral.');
+
+    const fields = ((self as any).fields ?? {}) as Fields;
+
+    const schemaWithId = Schema.extend(self, Schema.Struct({ id: Schema.String }));
+    const ast = SchemaAST.annotations(schemaWithId.ast, {
+      ...self.ast.annotations,
+      [TypeAnnotationId]: { kind: EntityKind.Type, typename, version } satisfies TypeAnnotation,
+      [SchemaAST.JSONSchemaAnnotationId]: makeTypeJsonSchemaAnnotation({
+        kind: EntityKind.Type,
+        typename,
+        version,
+      }),
+    });
+
+    return makeEchoTypeSchema<Self, EntityKind.Type, Fields>(
+      fields,
+      ast,
+      typename,
+      version,
+      EntityKind.Type,
+      () => toJsonSchema(Schema.make(ast)),
+      options?.id,
+    );
+  };
+};

package/src/internal/Entity/type-uri.ts

@@ -0,0 +1,92 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { raise } from '@dxos/debug';
+import { assertArgument } from '@dxos/invariant';
+import { DXN, EID, URI } from '@dxos/keys';
+
+import { getSchemaURI, getTypename } from '../Annotation/annotations';
+import { type AnyEntity, InstancePhantomId, KindId, TypeId, getStaticTypeSchema } from '../common/types';
+import { getUri as getUriFromEntity } from './api';
+
+/**
+ * @param input schema, `Type.Type` entity, or a type URI (an `echo:` EID or a `dxn:` DXN).
+ * @return type identifier URI — see {@link getSchemaURI}. A URI is returned verbatim. For a
+ * `Type.Type` entity, the URI of the schema it declares, symmetric with what
+ * `Obj.make(typeEntity, ...)` stamps on `system.type`: a static declaration resolves to its
+ * typename DXN, a persisted entity to its local `echo:/<objectId>`.
+ */
+export const getTypeURIFromSpecifier = (input: Schema.Schema.All | AnyEntity | URI.URI): URI.URI => {
+  if (Schema.isSchema(input)) {
+    return getSchemaURI(input) ?? raise(new TypeError('Schema has no URI'));
+  }
+  if (typeof input === 'object' && input !== null && KindId in input) {
+    // `Type.Type` entity. Both in-memory and persisted forms expose the schema
+    // they declare via `StaticTypeSchemaSlot`, whose URI is exactly what
+    // `Obj.make` stamps on `system.type` — a static declaration carries
+    // `TypeAnnotation` (→ typename DXN), a persisted entity's rebuilt schema
+    // carries `TypeIdentifierAnnotation` (→ local `echo:/<objectId>`).
+    const schema = getStaticTypeSchema(input);
+    if (schema != null) {
+      // Static types carry TypeAnnotation → DXN; persisted db types carry
+      // TypeIdentifierAnnotation → echo EID. In-memory makeObjectFromJsonSchema
+      // entities have neither (plain JSON Schema), so fall through to the EID path.
+      const uri = getSchemaURI(schema);
+      if (uri != null) {
+        return uri;
+      }
+    }
+    return getUriFromEntity(input as AnyEntity);
+  }
+  // A string specifier is already a branded URI — an `echo:` EID or a `dxn:` DXN.
+  assertArgument(EID.isEID(input) || DXN.isDXN(input), 'input', 'expected a type URI (EID or DXN)');
+  return input;
+};
+
+/**
+ * Checks if the object is an instance of the schema.
+ * Only typename is compared, the schema version is ignored.
+ *
+ * The following cases are considered to mean that the object is an instance of the schema:
+ *  - Object was created with this exact schema.
+ *  - Object was created with a different version of this schema.
+ *  - Object was created with a different schema (maybe dynamic) that has the same typename.
+ */
+// TODO(burdon): Can we use `Schema.is`?
+export const isInstanceOf = <S>(
+  schemaOrType: S extends Schema.Schema.AnyNoContext ? S : Schema.Schema.AnyNoContext | AnyEntity,
+  object: any,
+): object is S extends Schema.Schema.AnyNoContext
+  ? Schema.Schema.Type<S>
+  : S extends { readonly [InstancePhantomId]?: infer A }
+    ? A
+    : unknown => {
+  if (object == null) {
+    return false;
+  }
+
+  const schemaURI = getTypeURIFromSpecifier(schemaOrType);
+
+  // `object` is arbitrary input — read TypeId directly (it may be missing on
+  // non-entities) rather than via `getTypeURI` which asserts the URI is set.
+  const type = (object as any)[TypeId];
+  if (URI.isURI(type) && type === schemaURI) {
+    return true;
+  }
+
+  const typename = getTypename(object);
+  if (!typename) {
+    return false;
+  }
+
+  if (!DXN.isDXN(schemaURI)) {
+    // EID-based schema URI — no typename match possible.
+    return false;
+  }
+
+  const parsed = DXN.tryMake(schemaURI);
+  return parsed != null && DXN.getName(parsed) === typename;
+};

package/src/internal/Entity/util.ts

@@ -5,29 +5,29 @@
 import * as Schema from 'effect/Schema';
 
 import { assertArgument, invariant } from '@dxos/invariant';
-import { DXN, ObjectId } from '@dxos/keys';
+import { EID, EntityId } from '@dxos/keys';
 import { assumeType } from '@dxos/util';
 
-import { type InternalObjectProps, SelfDXNId } from './model';
+import { type InternalObjectProps, SelfURIId } from './model';
 
 /**
- * Returns a DXN for an object or schema.
+ * Returns the EID of an object.
  *
  * @internal
  */
-export const getObjectDXN = (object: any): DXN | undefined => {
+export const getObjectEchoUri = (object: any): EID.EID | undefined => {
   invariant(!Schema.isSchema(object), 'schema not allowed in this function');
   assertArgument(typeof object === 'object' && object != null, 'object', 'expected object');
   assumeType<InternalObjectProps>(object);
 
-  if (object[SelfDXNId]) {
-    invariant(object[SelfDXNId] instanceof DXN, 'Invalid object model: invalid self dxn');
-    return object[SelfDXNId];
+  if (object[SelfURIId]) {
+    invariant(EID.isEID(object[SelfURIId]), 'Invalid object model: invalid self dxn');
+    return EID.parse(object[SelfURIId]);
   }
 
-  if (!ObjectId.isValid(object.id)) {
+  if (!EntityId.isValid(object.id)) {
     throw new TypeError('Object id is not valid.');
   }
 
-  return DXN.fromLocalObjectId(object.id);
+  return EID.make({ entityId: object.id });
 };

package/src/internal/Format/date.ts

@@ -104,7 +104,6 @@ export const DateOnly = /* Schema.transformOrFail(Schema.String, SimpleDate, {
 }) */ Schema.String.pipe(
   FormatAnnotation.set(TypeFormat.Date),
   Schema.annotations({
-    title: 'Date',
     description: 'Valid date in ISO format',
   }),
 );
@@ -134,7 +133,6 @@ export const TimeOnly = /* Schema.transformOrFail(Schema.String, SimpleTime, {
 }) */ Schema.String.pipe(
   FormatAnnotation.set(TypeFormat.Time),
   Schema.annotations({
-    title: 'Time',
     description: 'Valid time in ISO format',
   }),
 );
@@ -179,7 +177,6 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
 }) */ Schema.String.pipe(
   FormatAnnotation.set(TypeFormat.DateTime),
   Schema.annotations({
-    title: 'DateTime',
     description: 'Valid date and time in ISO format',
   }),
 );
@@ -191,7 +188,6 @@ export const DateTime = /* Schema.transformOrFail(Schema.String, SimpleDateTime,
 export const Duration = Schema.String.pipe(
   FormatAnnotation.set(TypeFormat.Duration),
   Schema.annotations({
-    title: 'Duration',
     description: 'Duration in ISO 8601 format',
     [SchemaAST.ExamplesAnnotationId]: ['1h', '3D'],
   }),

package/src/internal/Format/format.test.ts

@@ -74,3 +74,24 @@ describe('formats', () => {
     }
   });
 });
+
+describe('GeoPoint', () => {
+  const decode = Schema.decodeUnknownSync(Format.GeoPoint);
+
+  test('rounds high-precision coordinates to 7 decimal places', ({ expect }) => {
+    // Live geocoders (e.g. Nominatim/OSRM) emit > 7 decimals; rounding keeps them valid GeoPoints.
+    expect(decode([-0.12776534, 51.50744561])).toEqual([-0.1277653, 51.5074456]);
+  });
+
+  test('passes through coordinates already within precision', ({ expect }) => {
+    expect(decode([2.3522, 48.8566])).toEqual([2.3522, 48.8566]);
+  });
+
+  test('preserves an optional altitude', ({ expect }) => {
+    expect(decode([-0.12776534, 51.50744561, 42])).toEqual([-0.1277653, 51.5074456, 42]);
+  });
+
+  test('clamps out-of-range coordinates', ({ expect }) => {
+    expect(decode([200, 100])).toEqual([180, 90]);
+  });
+});

package/src/internal/Format/index.ts

@@ -2,11 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-export type { SimpleDate, SimpleDateTime, SimpleTime } from './date';
+export * from './date';
+export * from './format';
 export { CurrencyAnnotationId, DecimalPrecision, Currency } from './number';
 export { GeoPoint, GeoLocation } from './object';
-
-export * from './format';
 export * from './select';
 export * from './string';
 export * from './types';