@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.1-main.c7dcc2e112

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

@@ -6,6 +6,10 @@ import * as Schema from 'effect/Schema';
 import type * as Types from 'effect/Types';
 import { describe, expect, test } from 'vitest';
 
+import { DXN } from '@dxos/keys';
+
+import * as Obj from '../../../Obj';
+import * as Type from '../../../Type';
 import { EchoObjectSchema } from '../../Entity';
 import { getSchema } from '../types';
 import { makeObject } from './make-object';
@@ -13,14 +17,9 @@ import { change } from './reactive';
 
 const Organization = Schema.Struct({
   name: Schema.String,
-}).pipe(
-  EchoObjectSchema({
-    typename: 'com.example.type.organization',
-    version: '0.1.0',
-  }),
-);
+}).pipe(EchoObjectSchema(DXN.make('com.example.type.organization', '0.1.0')));
 
-interface Organization extends Schema.Schema.Type<typeof Organization> {}
+type Organization = Type.InstanceType<typeof Organization>;
 
 const Contact = Schema.Struct(
   {
@@ -30,27 +29,21 @@ const Contact = Schema.Struct(
     key: Schema.String,
     value: Schema.Any,
   },
-).pipe(
-  Schema.partial,
-  EchoObjectSchema({
-    typename: 'com.example.type.person',
-    version: '0.1.0',
-  }),
-);
+).pipe(Schema.partial, EchoObjectSchema(DXN.make('com.example.type.person', '0.1.0')));
 
-interface Contact extends Schema.Schema.Type<typeof Contact> {}
+type Contact = Type.InstanceType<typeof Contact>;
 
-const TEST_ORG: Omit<Organization, 'id'> = { name: 'Test' };
+const TEST_ORG = { name: 'Test' } satisfies Pick<Organization, 'name'>;
 
 describe('EchoObjectSchema class DSL', () => {
   test('can get object schema', async () => {
-    const obj = makeObject(Organization, TEST_ORG);
-    expect(getSchema(obj)).to.deep.eq(Organization);
+    const obj = Obj.make(Organization, TEST_ORG);
+    expect(getSchema(obj)).to.deep.eq(Type.getSchema(Organization));
   });
 
   describe('class options', () => {
     test('can assign undefined to partial fields', async () => {
-      const person = makeObject(Contact, { name: 'John' });
+      const person = Obj.make(Contact, { name: 'John' });
       change(person, (p) => {
         p.name = undefined;
         p.recordField = 'hello';
@@ -86,7 +79,7 @@ describe('EchoObjectSchema class DSL', () => {
     }
 
     {
-      // Plain object (not a reactive proxy) - doesn't need Obj.change.
+      // Plain object (not a reactive proxy) - doesn't need Obj.update.
       // Note: Schema.Schema.Type generates readonly types, so we cast to mutable for plain objects.
       type Test1 = Types.Mutable<Schema.Schema.Type<typeof schema>>;
 
@@ -98,14 +91,9 @@ describe('EchoObjectSchema class DSL', () => {
     {
       const Test2 = Schema.Struct({
         meta: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-      }).pipe(
-        EchoObjectSchema({
-          typename: 'org.dxos.type.functionTrigger',
-          version: '0.1.0',
-        }),
-      );
-
-      const object = makeObject(Test2, {});
+      }).pipe(EchoObjectSchema(DXN.make('org.dxos.type.functionTrigger', '0.1.0')));
+
+      const object = Obj.make(Test2, {});
       change(object, (o) => {
         (o.meta ??= {}).test = 100;
       });

package/src/internal/common/types/base.ts

@@ -5,9 +5,9 @@
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { type ObjectId } from '@dxos/keys';
+import { type EntityId } from '@dxos/keys';
 
-import { type ATTR_META, type ObjectMeta } from './meta';
+import { type ATTR_META, type EntityMeta } from './meta';
 
 /**
  * Base type for all data objects (reactive, ECHO, and other raw objects).
@@ -23,7 +23,7 @@ export type AnyProperties = Record<string, any>;
  */
 // TODO(wittjosiah): Remove. Prefer higher level types (e.g. Entity.Unknown).
 export interface AnyEntity {
-  readonly id: ObjectId;
+  readonly id: EntityId;
 }
 
 export type ExcludeId<T extends AnyProperties> = Omit<T, 'id'>;
@@ -31,7 +31,7 @@ export type ExcludeId<T extends AnyProperties> = Omit<T, 'id'>;
 export type PropertyKey<T extends AnyProperties> = Extract<keyof ExcludeId<T>, string>;
 
 // TODO(dmaretskyi): Remove. This should be using the symbol type.
-type WithMeta = { [ATTR_META]?: ObjectMeta };
+type WithMeta = { [ATTR_META]?: EntityMeta };
 
 /**
  * The raw object should not include the ECHO id, but may include metadata.

package/src/internal/common/types/entity.ts

@@ -33,11 +33,90 @@ export const SnapshotKindId = '~@dxos/echo/SnapshotKind' as const;
 export type SnapshotKindId = typeof SnapshotKindId;
 
 /**
- * Kinds of entities stored in ECHO: objects and relations.
+ * Hidden slot on a static `Type.Type` entity that holds the source Effect
+ * Schema. `Type.getSchema(...)` reads this for static types; persisted types
+ * rebuild from `jsonSchema` instead. Stored as a string key for declaration
+ * portability (see KindId comment above).
+ */
+export const StaticTypeSchemaSlot = '~@dxos/echo/Type.StaticSchema' as const;
+export type StaticTypeSchemaSlot = typeof StaticTypeSchemaSlot;
+
+/**
+ * Read the hidden `StaticTypeSchemaSlot` off any value that may carry one.
+ * Returns `undefined` for raw schemas (no slot) and non-object inputs.
+ * Single point-of-cast for the slot lookup.
+ */
+export const getStaticTypeSchema = (value: unknown): Schema.Schema.AnyNoContext | undefined => {
+  if (value == null || typeof value !== 'object') {
+    return undefined;
+  }
+  return (value as { [StaticTypeSchemaSlot]?: Schema.Schema.AnyNoContext })[StaticTypeSchemaSlot];
+};
+
+/**
+ * Read the `[SchemaKindId]` brand off a value. Returns `undefined` for raw
+ * schemas (which don't carry the brand on their static type) and non-object
+ * inputs. Single point-of-cast for the brand lookup.
+ */
+export const getSchemaKind = (value: unknown): EntityKind | undefined => {
+  if (value == null || typeof value !== 'object') {
+    return undefined;
+  }
+  return (value as { [SchemaKindId]?: EntityKind })[SchemaKindId];
+};
+
+/**
+ * Read the `[KindId]` brand off a value. Returns `undefined` for raw schemas
+ * and non-object inputs. Companion to {@link getSchemaKind}.
+ */
+export const getEntityKindBrand = (value: unknown): EntityKind | undefined => {
+  if (value == null || typeof value !== 'object') {
+    return undefined;
+  }
+  return (value as { [KindId]?: EntityKind })[KindId];
+};
+
+/**
+ * Phantom string key on `Type<A>` entities that carries the instance type `A`.
+ * Lets internal helpers (`makeObject`, `createObject`, etc.) pattern-match the
+ * instance type from an entity input without importing from the top-level
+ * `Type` module. Mirrors `Type.InstancePhantomId` (declared in `Type.ts`).
+ *
+ * Stored as a string key so declarations remain portable across packages
+ * (see KindId comment above).
+ */
+export const InstancePhantomId = '~@dxos/echo/Type.Instance' as const;
+export type InstancePhantomId = typeof InstancePhantomId;
+
+/**
+ * Nominal brand carried by the well-known "any object" / "any relation"
+ * schemas (`Obj.Unknown`, `Relation.Unknown`). The brand lets `Ref.Ref`,
+ * `Filter.type`, and `Query.type` accept these schemas in addition to
+ * `Type.Type` entities, without opening the door to arbitrary raw schemas.
+ *
+ * Stored as a string key so declarations remain portable across packages
+ * (see KindId comment above).
+ */
+export const UnknownTypeSchemaBrandId = '~@dxos/echo/UnknownTypeSchemaBrand' as const;
+export type UnknownTypeSchemaBrandId = typeof UnknownTypeSchemaBrandId;
+
+/**
+ * Schema-side companion to `Type.Type` entities for the "any object" /
+ * "any relation" cases. Branded so `Ref.Ref` / `Filter.type` / `Query.type`
+ * can pattern-match on it; arbitrary `Schema.Schema` values do not satisfy
+ * this shape.
+ */
+export interface UnknownTypeSchema<A, K extends EntityKind> extends Schema.Schema<A, any, never> {
+  readonly [UnknownTypeSchemaBrandId]: K;
+}
+
+/**
+ * Kinds of entities stored in ECHO: objects, relations, and types.
  */
 export enum EntityKind {
   Object = 'object',
   Relation = 'relation',
+  Type = 'type',
 }
 
 export const EntityKindSchema = Schema.Enums(EntityKind);

package/src/internal/common/types/index.ts

@@ -4,7 +4,12 @@
 
 export * from './base';
 export * from './entity';
-export * from './meta';
+// NOTE: `./meta` is intentionally NOT re-exported here. It depends on the Ref schema (`Ref/ref`),
+// which transitively pulls in `Annotation` + `Database`; re-exporting it from this low-level barrel
+// — imported by `Annotation/util`, `Annotation/annotations`, `Entity/type-uri`, and `Ref/ref` —
+// would create an eval-order cycle (TDZ on `createAnnotationHelper`). Import meta from `./meta`
+// directly, or from the top-level `@dxos/echo/internal` barrel (re-exported there after Ref loads).
 export * from './model-symbols';
 export * from './typename';
 export * from './version';
+export * from './well-known-types';

package/src/internal/common/types/meta.ts

@@ -4,43 +4,85 @@
 
 import * as Schema from 'effect/Schema';
 
-import { ForeignKey } from '@dxos/echo-protocol';
+import { type EncodedReference, ForeignKey } from '@dxos/echo-protocol';
 import { invariant } from '@dxos/invariant';
+import { DXN } from '@dxos/keys';
 import { type Comparator, intersection } from '@dxos/util';
 
-import type * as Entity from '../../../Entity';
+import type * as Tag from '../../../Tag';
+import { Dictionary } from '../../Annotation/dictionary';
+// `meta` is no longer re-exported from the `common/types` barrel (see ./index.ts), so importing the
+// Ref schema builder here no longer forms an eval-order cycle with `Annotation`/`Database`.
+import { type Ref, createEchoReferenceSchema } from '../../Ref/ref';
 import { type AnyProperties } from './base';
+import { MetaId } from './model-symbols';
+import { TagTypeDXN } from './well-known-types';
 
 /**
  * Property name for meta when object is serialized to JSON.
  */
 export const ATTR_META = '@meta';
 
-/**
- * Metadata section.
- */
-export const MetaId: Entity.Meta = Symbol.for('@dxos/echo/Meta') as any;
-
 //
-// ObjectMeta
+// EntityMeta
 //
 
-// TODO(dmaretskyi): Rename to ObjectMeta
-export const ObjectMetaSchema = Schema.Struct({
+/**
+ * Schema for references to {@link Tag} objects stored in {@link EntityMetaSchema.tags}.
+ *
+ * Built from the shared {@link createEchoReferenceSchema} (the same builder `Ref.Ref` uses) via
+ * `Schema.suspend`, so it reuses the canonical ref codec rather than duplicating it. The Tag type
+ * identity comes from the shared {@link TagTypeDXN} constant; `suspend` defers construction until
+ * first use, and `Tag` is referenced type-only, so no `Tag` value import is needed.
+ */
+const TagRefSchema = Schema.suspend(
+  (): Schema.Schema<Ref<Tag.Tag>, EncodedReference> =>
+    // The factory yields a loosely-typed `Ref<any>` schema; narrow it to the Tag-typed ref.
+    createEchoReferenceSchema(undefined, DXN.getName(TagTypeDXN), DXN.getVersion(TagTypeDXN)) as Schema.Schema<
+      Ref<Tag.Tag>,
+      EncodedReference
+    >,
+);
+
+export const EntityMetaSchema = Schema.Struct({
   keys: Schema.Array(ForeignKey),
 
   /**
-   * A set of tags.
-   * Tags are arbitrary application-defined strings.
-   * ECHO makes no assumptions about the tag structure.
+   * Tags applied to this entity, as references to {@link Tag} objects.
+   */
+  tags: Schema.Array(TagRefSchema),
+
+  /**
+   * Fully-qualified registry key for the object (FQN format, e.g. `org.example.type.foo`).
+   * Identifies the canonical registry entry the object instance was created from.
+   */
+  key: Schema.optional(Schema.String),
+
+  /**
+   * Semantic version of the registry entry the object was created from.
+   * Must be a valid semver string (e.g. `1.2.3`).
+   */
+  version: Schema.optional(Schema.String),
+
+  /**
+   * Dictionary of annotations to this entity.
+   */
+  annotations: Dictionary,
+
+  /**
+   * Unix ms timestamp when this entity was created.
+   * Read-only; sourced from the system section of the automerge document — not stored in meta.
+   */
+  createdAt: Schema.optional(Schema.Number),
+
+  /**
+   * Unix ms timestamp of the last automerge change on this entity's document.
+   * Read-only; derived from the automerge change graph — not stored in meta.
    */
-  // TODO(dmaretskyi): Has to be optional for compatibility with old data.
-  // Defaulting to an empty array is possible but requires a bit more work.
-  // TODO(dmaretskyi): In automerge this should be a map of { [tag]: boolean } for uniqueness and conflict resolution.
-  tags: Schema.optional(Schema.Array(Schema.String)),
+  updatedAt: Schema.optional(Schema.Number),
 });
 
-export type ObjectMeta = Schema.Schema.Type<typeof ObjectMetaSchema>;
+export type EntityMeta = Schema.Schema.Type<typeof EntityMetaSchema>;
 
 /*
  * Get metadata from object.
@@ -49,9 +91,9 @@ export type ObjectMeta = Schema.Schema.Type<typeof ObjectMetaSchema>;
  * @internal (use Obj.getMeta or Relation.getMeta)
  */
 // TODO(burdon): Refine type to BaseObj.
-export const getMeta = (obj: AnyProperties): ObjectMeta => {
+export const getMeta = (obj: AnyProperties): EntityMeta => {
   const metadata = (obj as any)[MetaId];
-  invariant(metadata, 'ObjectMeta not found.');
+  invariant(metadata, 'EntityMeta not found.');
   return metadata;
 };
 

package/src/internal/common/types/model-symbols.ts

@@ -2,6 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
+// TODO(rename): These internal entity-wide symbols/types still use the `Object*` prefix but apply
+// to all entities (objects AND relations). Rename to `Entity*` in a follow-up pass (deferred from the
+// EchoURI→EID / ObjectId→EntityId / ObjectMeta→EntityMeta rename, which covered only public SDK API):
+//   ObjectCore, ObjectInternals, ObjectVersion, ObjectVersionId, ObjectDeletedId, ObjectDatabaseId,
+//   ObjectLoader, ObjectDocumentLoaded, ObjectUnavailable.
+// (ObjectMigration / ObjectMigrationContext intentionally excluded — object-only, not entity-wide.)
+
 /**
  * Internal symbol/string constants for the echo object model.
  * Defined in common/ so proxy/ can use them without importing from Entity/.
@@ -9,14 +16,19 @@
  */
 
 /**
- * Property name for self DXN when object is serialized to JSON.
+ * Property name for the object's own URI when serialized to JSON.
+ */
+export const ATTR_SELF_URI = '@uri';
+
+/**
+ * @deprecated Legacy JSON property name accepted on read for backward compat.
  */
-export const ATTR_SELF_DXN = '@dxn';
+export const ATTR_SELF_URI_LEGACY = '@dxn';
 
 /**
- * DXN to the object itself.
+ * Symbol carrying the object's own URI on live entities.
  */
-export const SelfDXNId = Symbol.for('@dxos/echo/DXN');
+export const SelfURIId = Symbol.for('@dxos/echo/URI');
 
 /**
  * Property name for deleted when object is serialized to JSON.
@@ -67,3 +79,11 @@ export const RelationTargetId: unique symbol = Symbol.for('@dxos/echo/RelationTa
  * Used to access relation target DXN on live ECHO objects.
  */
 export const RelationTargetDXNId: unique symbol = Symbol.for('@dxos/echo/RelationTargetDXN');
+
+/**
+ * Symbol carrying the entity metadata (EntityMeta) on live ECHO entities.
+ * Must be importable by both meta.ts (which depends on the Ref schema) and
+ * Entity/api.ts (which is transitively imported by the Ref schema), so it
+ * cannot live in either of those files without creating an import cycle.
+ */
+export const MetaId = Symbol.for('@dxos/echo/Meta');

package/src/internal/common/types/typename.ts

@@ -30,11 +30,20 @@ export const ATTR_PARENT = '@parent';
 export const ParentId = Symbol.for('@dxos/echo/Parent');
 
 /**
- * Returns the schema for the given object if one is defined.
+ * Reference to the object's type entity (`Type.Obj`, `Type.Relation`, or
+ * `Type.Type`). Set at instance creation by `createObject` / `makeObject`
+ * when the entity is known. Public read-back via `Obj.getType` / `Relation.getType`
+ * / `Entity.getType`.
+ */
+export const TypeEntityId = Symbol.for('@dxos/echo/TypeEntity');
+
+/**
+ * Returns the Effect Schema for the given object if one is defined.
  *
- * @internal (Use Obj.getSchema)
+ * @internal
+ * Internal callers needing schema-side validation read from `SchemaId`.
+ * Public callers should use `Type.getSchema(Obj.getType(obj))` instead.
  */
-// TODO(burdon): Narrow type.
 // TODO(dmaretskyi): For echo objects, this always returns the root schema.
 export const getSchema = (obj: unknown | undefined): Schema.Schema.AnyNoContext | undefined => {
   if (obj) {
@@ -53,3 +62,30 @@ export const setSchema = (obj: any, schema: Schema.Schema.AnyNoContext): void =>
     configurable: false,
   });
 };
+
+/**
+ * Returns the type entity (`Type.AnyEntity`) for the given instance.
+ * Set at instance creation; every entity has a type. Defensive: returns
+ * undefined for null/undefined input so callers can safely probe arbitrary
+ * values via this helper.
+ *
+ * @internal Re-exported via `Obj.getType` / `Relation.getType` / `Entity.getType`.
+ */
+export const getType = (obj: unknown): unknown => {
+  if (obj == null) {
+    return undefined;
+  }
+  return (obj as any)[TypeEntityId];
+};
+
+/**
+ * @internal
+ */
+export const setType = (obj: any, type: unknown): void => {
+  Object.defineProperty(obj, TypeEntityId, {
+    value: type,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  });
+};

package/src/internal/common/types/well-known-types.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { DXN } from '@dxos/keys';
+
+/**
+ * DXN identity of the system {@link Tag} type.
+ *
+ * Defined in this low-level leaf so it can be shared by the public `Tag` type (which brands the
+ * schema with this DXN) and by `EntityMetaSchema.tags` (which builds a `Ref<Tag>` schema from it)
+ * without either importing the other — `Tag` is top-level and `meta` is deep-internal, so a direct
+ * dependency between them would form an eval-order cycle.
+ */
+export const TagTypeDXN = DXN.make('org.dxos.type.tag', '0.1.0');

package/src/internal/index.ts

@@ -2,9 +2,6 @@
 // Copyright 2024 DXOS.org
 //
 
-// TODO(burdon): Import directly (not part of ECHO API).
-export { JsonPath, JsonProp, getValue, splitJsonPath } from '@dxos/effect';
-
 export * from './Annotation';
 export * from './common';
 export * from './Entity';
@@ -12,6 +9,11 @@ export * from './Format';
 export * from './JsonSchema';
 // TODO(wittjosiah): Required to ensure types are portable (need to export all types required for downstream inference).
 export * from './Obj';
-export * from './Query';
+export { prettyFilter, prettyQuery } from './Query/pretty';
 export * from './Ref';
 export * from './Type';
+
+// Re-exported here (not from the low-level `common/types` barrel) so consumers keep importing meta
+// from `@dxos/echo/internal`, while that barrel stays free of the Ref/Annotation eval cycle. Placed
+// after `./Ref` so the ref schema `meta` depends on is initialized first.
+export * from './common/types/meta';

package/src/testing/api.test.ts

@@ -13,16 +13,22 @@ import { TestSchema } from './test-schema';
 describe('Experimental API review', () => {
   test('type checks', ({ expect }) => {
     const contact = Obj.make(TestSchema.Person, { name: 'Test' });
-    const schema = Obj.getSchema(contact) ?? raise(new Error('No schema found'));
-
-    expect(Type.getDXN(schema)?.typename).to.eq(TestSchema.Person.typename);
-    expect(Type.getTypename(schema)).to.eq('com.example.type.person');
-    expect(Type.getVersion(schema)).to.eq('0.1.0');
-    expect(Type.getMeta(schema)).to.deep.eq({
-      kind: Entity.Kind.Object,
-      typename: 'com.example.type.person',
+    const type = Obj.getType(contact) ?? raise(new Error('No type found'));
+
+    expect(Type.getTypename(type)).to.eq(Type.getTypename(TestSchema.Person));
+    expect(Type.getTypename(type)).to.eq('com.example.type.person');
+    expect(Type.getVersion(type)).to.eq('0.1.0');
+    // `Type.getMeta` returns `EntityMeta` (`{ keys, tags?, key?, version? }`) —
+    // the same shape `Obj.getMeta` and `Relation.getMeta` return. The
+    // schema-kind brand lives on `[SchemaKindId]`, not in meta.
+    expect(Type.getMeta(type)).to.deep.eq({
+      keys: [],
+      tags: [],
+      annotations: {},
+      key: 'com.example.type.person',
       version: '0.1.0',
     });
+    expect(Type.isObject(type)).to.be.true;
   });
 
   test('instance checks', ({ expect }) => {
@@ -32,7 +38,7 @@ describe('Experimental API review', () => {
       employer: Ref.make(organization),
     });
 
-    expect(Schema.is(TestSchema.Person)(contact)).to.be.true;
+    expect(Schema.is(Type.getSchema(TestSchema.Person))(contact)).to.be.true;
     expect(Obj.instanceOf(TestSchema.Person, contact)).to.be.true;
     expect(Obj.instanceOf(TestSchema.Organization, organization)).to.be.true;
 

package/src/testing/index.ts

@@ -2,6 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
+export * from './registry';
 export * from './test-data';
 export * from './test-schema';
 export * from './util';

package/src/testing/registry.ts

@@ -0,0 +1,44 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Atom from '@effect-atom/atom/Atom';
+import * as Layer from 'effect/Layer';
+
+import { Event } from '@dxos/async';
+
+import * as Registry from '../Registry';
+
+/**
+ * Noop `Registry.Service` layer for testing — always returns empty query results.
+ * Use this in test layer stacks that require `Registry.Service` but don't need
+ * actual registry contents.
+ */
+export const registryLayerNoop: Layer.Layer<Registry.Service> = Layer.succeed(Registry.Service, {
+  [Registry.TypeId]: Registry.TypeId,
+  id: 'noop-registry',
+  changed: new Event<void>(),
+  local: [],
+  add: () => {},
+  remove: () => false,
+  clear: () => {},
+  get: () => undefined,
+  getByURI: () => undefined,
+  list: () => [],
+  // QueryFn is an overloaded interface — a single generic function cannot satisfy both overload
+  // signatures without a cast. This is the intentional type-system boundary.
+  query: ((_queryOrFilter: unknown) => ({
+    results: [],
+    entries: [],
+    run: async () => [],
+    runEntries: async () => [],
+    runSync: () => [],
+    runSyncEntries: () => [],
+    first: async (): Promise<never> => {
+      throw new Error('registryLayerNoop: registry is empty');
+    },
+    firstOrUndefined: async () => undefined,
+    subscribe: () => () => {},
+    atom: Atom.make((): never[] => []),
+  })) as Registry.Registry['query'],
+} satisfies Registry.Registry);