@dxos/echo 0.8.4-main.ef1bc66f44 → 0.8.4-main.effb148878

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo",
-  "version": "0.8.4-main.ef1bc66f44",
+  "version": "0.8.4-main.effb148878",
   "description": "ECHO API",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/dxos/dxos"
   },
-  "license": "MIT",
+  "license": "FSL-1.1-Apache-2.0",
   "author": "info@dxos.org",
   "sideEffects": false,
   "type": "module",
@@ -48,6 +48,11 @@
       "types": "./dist/types/src/Err.d.ts",
       "default": "./dist/lib/neutral/Err.mjs"
     },
+    "./Feed": {
+      "source": "./src/Feed.ts",
+      "types": "./dist/types/src/Feed.d.ts",
+      "default": "./dist/lib/neutral/Feed.mjs"
+    },
     "./Filter": {
       "source": "./src/Filter.ts",
       "types": "./dist/types/src/Filter.d.ts",
@@ -68,6 +73,11 @@
       "types": "./dist/types/src/Key.d.ts",
       "default": "./dist/lib/neutral/Key.mjs"
     },
+    "./Migration": {
+      "source": "./src/Migration.ts",
+      "types": "./dist/types/src/Migration.d.ts",
+      "default": "./dist/lib/neutral/Migration.mjs"
+    },
     "./Obj": {
       "source": "./src/Obj.ts",
       "types": "./dist/types/src/Obj.d.ts",
@@ -112,6 +122,11 @@
       "source": "./src/Type.ts",
       "types": "./dist/types/src/Type.d.ts",
       "default": "./dist/lib/neutral/Type.mjs"
+    },
+    "./Extension": {
+      "source": "./src/Extension.ts",
+      "types": "./dist/types/src/Extension.d.ts",
+      "default": "./dist/lib/neutral/Extension.mjs"
     }
   },
   "files": [
@@ -119,19 +134,19 @@
     "src"
   ],
   "dependencies": {
-    "effect": "3.19.16",
-    "@dxos/async": "0.8.4-main.ef1bc66f44",
-    "@dxos/debug": "0.8.4-main.ef1bc66f44",
-    "@dxos/context": "0.8.4-main.ef1bc66f44",
-    "@dxos/effect": "0.8.4-main.ef1bc66f44",
-    "@dxos/echo-protocol": "0.8.4-main.ef1bc66f44",
-    "@dxos/errors": "0.8.4-main.ef1bc66f44",
-    "@dxos/invariant": "0.8.4-main.ef1bc66f44",
-    "@dxos/log": "0.8.4-main.ef1bc66f44",
-    "@dxos/protocols": "0.8.4-main.ef1bc66f44",
-    "@dxos/keys": "0.8.4-main.ef1bc66f44",
-    "@dxos/node-std": "0.8.4-main.ef1bc66f44",
-    "@dxos/util": "0.8.4-main.ef1bc66f44"
+    "effect": "3.20.0",
+    "@dxos/async": "0.8.4-main.effb148878",
+    "@dxos/debug": "0.8.4-main.effb148878",
+    "@dxos/echo-protocol": "0.8.4-main.effb148878",
+    "@dxos/effect": "0.8.4-main.effb148878",
+    "@dxos/context": "0.8.4-main.effb148878",
+    "@dxos/errors": "0.8.4-main.effb148878",
+    "@dxos/invariant": "0.8.4-main.effb148878",
+    "@dxos/keys": "0.8.4-main.effb148878",
+    "@dxos/log": "0.8.4-main.effb148878",
+    "@dxos/node-std": "0.8.4-main.effb148878",
+    "@dxos/protocols": "0.8.4-main.effb148878",
+    "@dxos/util": "0.8.4-main.effb148878"
   },
   "publishConfig": {
     "access": "public"

package/src/Annotation.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 export {
   DescriptionAnnotation,
   FormInputAnnotation,
@@ -15,11 +17,13 @@ export {
   getTypeAnnotation,
   setDescriptionWithSchema,
   setLabelWithSchema,
-} from './internal/annotations';
+  IconAnnotation,
+  IconFromRefAnnotation,
+} from './internal/Annotation';
 
 import type * as Schema from 'effect/Schema';
 
-import * as internalAnnotations from './internal/annotations';
+import * as internalAnnotations from './internal/Annotation';
 
 interface MakeProps<T> {
   id: string;
@@ -34,7 +38,7 @@ interface MakeProps<T> {
  * @example
  * ```ts
  * const ColorAnnotation = Annotation.make({
- *   id: 'dxos.org/annotation/Color',
+ *   id: 'org.dxos.annotation.color',
  *   schema: Schema.String,
  * });
  *

package/src/Collection.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { DXN } from '@dxos/keys';
+
+import * as Annotation from './Annotation';
+import * as internal from './internal';
+import * as Obj from './Obj';
+import * as Ref from './Ref';
+import * as Type from './Type';
+
+/**
+ * A an ordered set of objects.
+ */
+export const Collection = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  objects: Schema.Array(Ref.Ref(Obj.Unknown)).pipe(internal.FormInputAnnotation.set(false)),
+}).pipe(
+  Annotation.IconAnnotation.set({
+    icon: 'ph--folder--regular',
+    hue: 'amber',
+  }),
+  Type.makeObject(DXN.make('org.dxos.type.collection', '0.1.0')),
+);
+
+export type Collection = Type.InstanceType<typeof Collection>;
+
+export const make = (props: Partial<Obj.MakeProps<typeof Collection>> = {}): Collection =>
+  Obj.make(Collection, { objects: [], ...props });
+
+export const isCollection: (value: unknown) => value is Collection = Obj.instanceOf(Collection);

package/src/Database.ts

@@ -2,6 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Layer from 'effect/Layer';
@@ -9,75 +11,36 @@ import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 import type * as Types from 'effect/Types';
 
-import { type QueryAST } from '@dxos/echo-protocol';
 import { promiseWithCauseCapture } from '@dxos/effect';
 import { invariant } from '@dxos/invariant';
-import { DXN, type PublicKey, type SpaceId } from '@dxos/keys';
-import { type QueryOptions as QueryOptionsProto } from '@dxos/protocols/proto/dxos/echo/filter';
+import { type SpaceId, type URI } from '@dxos/keys';
 
 import type * as Entity from './Entity';
 import * as Err from './Err';
 import type * as Filter from './Filter';
 import type * as Hypergraph from './Hypergraph';
-import { isInstanceOf } from './internal/annotations';
-import type { Ref } from './internal/ref/ref';
-import { type AnyProperties } from './internal/types';
+import { type AnyProperties } from './internal/common/types';
+// Deep import (not the `./internal/Entity` barrel) to avoid a cycle:
+// Database → internal/Entity → entity → JsonSchema → Ref → Database.
+import { isInstanceOf } from './internal/Entity/type-uri';
+import type { Ref } from './internal/Ref/ref';
 import type * as Obj from './Obj';
 import type * as Query from './Query';
 import type * as QueryResult from './QueryResult';
 import type * as SchemaRegistry from './SchemaRegistry';
 import type * as Type from './Type';
 
-/**
- * @deprecated Use `QueryAST.QueryOptions` instead.
- */
-export type QueryOptions = {
-  /**
-   * @deprecated Use `spaceIds` instead.
-   */
-  spaces?: PublicKey[];
-
-  /**
-   * Query only in specific spaces.
-   */
-  // TODO(dmaretskyi): Change this to SpaceId.
-  spaceIds?: string[];
-
-  /**
-   * Return only the first `limit` results.
-   */
-  limit?: number;
-
-  /**
-   * Query only local spaces, or remote on agent.
-   * @default `QueryOptions.DataLocation.LOCAL`
-   *
-   * Options:
-   *   - proto3_optional = true
-   */
-  // TODO(burdon): Remove?
-  dataLocation?: QueryOptionsProto.DataLocation;
-};
-
 /**
  * `query` API function declaration.
  */
 // TODO(burdon): Reconcile Query and Filter (should only have one root type).
-// TODO(dmaretskyi): Remove query options.
 export interface QueryFn {
-  <Q extends Query.Any>(
-    query: Q,
-    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,
-  ): QueryResult.QueryResult<Query.Type<Q>>;
-
-  <F extends Filter.Any>(
-    filter: F,
-    options?: (QueryAST.QueryOptions & QueryOptions) | undefined,
-  ): QueryResult.QueryResult<Filter.Type<F>>;
+  <Q extends Query.Any>(query: Q): QueryResult.QueryResult<Query.Type<Q>>;
+  <F extends Filter.Any>(filter: F): QueryResult.QueryResult<Filter.Type<F>>;
 }
 
 /**
- * Common interface for Database and Queue.
+ * Common interface for Database, Feed, and Hypergraph.
  */
 export interface Queryable {
   query: QueryFn;
@@ -110,7 +73,7 @@ export type FlushOptions = {
 
   /**
    * Wait for pending index updates.
-   * @default false
+   * @default true
    */
   indexes?: boolean;
 
@@ -145,7 +108,10 @@ export interface Database extends Queryable {
   /**
    * Return object by local ID.
    */
-  getObjectById<T extends Obj.Unknown = Obj.Obj<AnyProperties>>(id: string, opts?: GetObjectByIdOptions): T | undefined;
+  getObjectById<T extends Obj.Unknown = Obj.OfShape<AnyProperties>>(
+    id: string,
+    opts?: GetObjectByIdOptions,
+  ): T | undefined;
 
   /**
    * Query objects.
@@ -156,11 +122,11 @@ export interface Database extends Queryable {
    * Creates a reference to an existing object in the database.
    *
    * NOTE: The reference may be dangling if the object is not present in the database.
-   * NOTE: Difference from `Ref.fromDXN`
-   * `Ref.fromDXN(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.
+   * NOTE: Difference from `Ref.fromURI`
+   * `Ref.fromURI(dxn)` returns an unhydrated reference. The `.load` and `.target` APIs will not work.
    * `db.makeRef(dxn)` is preferable in cases with access to the database.
    */
-  makeRef<T extends Entity.Unknown = Entity.Unknown>(dxn: DXN): Ref<T>;
+  makeRef<T extends Entity.Unknown = Entity.Unknown>(uri: URI.URI): Ref<T>;
 
   /**
    * Adds object to the database.
@@ -237,19 +203,19 @@ export const spaceId = Effect.gen(function* () {
  */
 export const resolve: {
   // No type check.
-  (ref: DXN | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;
+  (ref: URI.URI | Ref<any>): Effect.Effect<Entity.Unknown, never, Service>;
   // Check matches schema.
-  <S extends Type.Entity.Any>(
-    ref: DXN | Ref<any>,
+  <S extends Type.AnyEntity>(
+    ref: URI.URI | Ref<any>,
     schema: S,
-  ): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service>;
-} = (<S extends Type.Entity.Any>(
-  ref: DXN | Ref<any>,
+  ): Effect.Effect<Type.InstanceType<S>, Err.ObjectNotFoundError, Service>;
+} = (<S extends Type.AnyEntity>(
+  ref: URI.URI | Ref<any>,
   schema?: S,
-): Effect.Effect<Schema.Schema.Type<S>, Err.ObjectNotFoundError, Service> =>
+): Effect.Effect<Type.InstanceType<S>, Err.ObjectNotFoundError, Service> =>
   Effect.gen(function* () {
     const { db } = yield* Service;
-    const dxn = ref instanceof DXN ? ref : ref.dxn;
+    const dxn = typeof ref === 'string' ? ref : ref.uri;
     const object = yield* promiseWithCauseCapture(() =>
       db.graph
         .createRefResolver({
@@ -263,26 +229,32 @@ export const resolve: {
     if (!object) {
       return yield* Effect.fail(new Err.ObjectNotFoundError(dxn));
     }
-    invariant(!schema || isInstanceOf(schema, object), 'Object type mismatch.');
+    // `isInstanceOf` uses a conditional generic that TS can't resolve through
+    // the local `S extends Type.AnyEntity` parameter — runtime accepts it fine.
+    invariant(!schema || isInstanceOf(schema as any, object), 'Object type mismatch.');
     return object as any;
-  })) as any;
+  }).pipe(Effect.withSpan('Database.resolve'))) as any;
 
 /**
  * Loads an object reference.
  */
-export const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn(function* (ref) {
-  const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
-  if (!object) {
-    return yield* Effect.fail(new Err.ObjectNotFoundError(ref.dxn));
-  }
-  return object;
-});
+export const load: <T>(ref: Ref<T>) => Effect.Effect<T, Err.ObjectNotFoundError, never> = Effect.fn('Database.load')(
+  function* (ref) {
+    const object = yield* promiseWithCauseCapture(() => ref.tryLoad());
+    if (!object) {
+      return yield* Effect.fail(new Err.ObjectNotFoundError(ref.uri));
+    }
+    return object;
+  },
+);
 
 /**
  * Loads an object reference option.
  */
 // TODO(dmaretskyi): Do we need this -- you can just use `Effect.catchTag` in calling code instead.
-export const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(function* (ref) {
+export const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, never, never> = Effect.fn(
+  'Database.loadOption',
+)(function* (ref) {
   const object = yield* load(ref).pipe(Effect.catchTag('ObjectNotFoundError', () => Effect.succeed(undefined)));
 
   return Option.fromNullable(object);
@@ -293,21 +265,23 @@ export const loadOption: <T>(ref: Ref<T>) => Effect.Effect<Option.Option<T>, nev
  * @see {@link Database.add}
  */
 export const add = <T extends Entity.Unknown>(obj: T): Effect.Effect<T, never, Service> =>
-  Service.pipe(Effect.map(({ db }) => db.add(obj)));
+  Service.pipe(Effect.map(({ db }) => db.add(obj))).pipe(Effect.withSpan('Database.add'));
 
 /**
  * Removes an object from the database.
  * @see {@link Database.remove}
  */
 export const remove = <T extends Entity.Unknown>(obj: T): Effect.Effect<void, never, Service> =>
-  Service.pipe(Effect.map(({ db }) => db.remove(obj)));
+  Service.pipe(Effect.map(({ db }) => db.remove(obj))).pipe(Effect.withSpan('Database.remove'));
 
 /**
  * Flushes pending changes to disk.
  * @see {@link Database.flush}
  */
 export const flush = (opts?: FlushOptions) =>
-  Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts))));
+  Service.pipe(Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.flush(opts)))).pipe(
+    Effect.withSpan('Database.flush'),
+  );
 
 /**
  * Creates a `QueryResult` object that can be subscribed to.
@@ -328,7 +302,36 @@ export const runQuery: {
   <Q extends Query.Any>(query: Q): Effect.Effect<Query.Type<Q>[], never, Service>;
   <F extends Filter.Any>(filter: F): Effect.Effect<Filter.Type<F>[], never, Service>;
 } = (queryOrFilter: Query.Any | Filter.Any) =>
-  query(queryOrFilter as any).pipe(Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())));
+  query(queryOrFilter as any).pipe(
+    Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),
+    Effect.withSpan('Database.runQuery'),
+  );
+
+/**
+ * Executes the query once and returns the first result as or None.
+ */
+export const runQueryFirst: {
+  <Q extends Query.Any>(query: Q): Effect.Effect<Option.Option<Query.Type<Q>>, never, Service>;
+  <F extends Filter.Any>(filter: F): Effect.Effect<Option.Option<Filter.Type<F>>, never, Service>;
+} = (queryOrFilter: Query.Any | Filter.Any) =>
+  query(queryOrFilter as any).pipe(
+    Effect.flatMap((queryResult) =>
+      promiseWithCauseCapture(async () => Option.fromNullable(await queryResult.firstOrUndefined())),
+    ),
+    Effect.withSpan('Database.runQueryFirst'),
+  );
+
+/**
+ * Persists schemas in the database so they replicate to other clients.
+ * @see {@link SchemaRegistry.SchemaRegistry.register}
+ */
+export const registerSchema = (
+  input: SchemaRegistry.RegisterSchemaInput[],
+): Effect.Effect<Type.Type[], never, Service> =>
+  Service.pipe(
+    Effect.flatMap(({ db }) => promiseWithCauseCapture(() => db.schemaRegistry.register(input))),
+    Effect.withSpan('Database.registerSchema'),
+  );
 
 /**
  * Creates a schema query result that can be subscribed to.
@@ -336,7 +339,7 @@ export const runQuery: {
 // TODO(dmaretskyi): Change API to `yield* Database.querySchema(...).first` and `yield* Database.querySchema(...).schema`.
 export const schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(
   schemaQueryOptions?: Q & SchemaRegistry.Query,
-): Effect.Effect<QueryResult.QueryResult<SchemaRegistry.ExtractQueryResult<Q>>, never, Service> =>
+): Effect.Effect<QueryResult.QueryResult<Type.Type>, never, Service> =>
   Service.pipe(
     Effect.map(({ db }) => db.schemaRegistry.query(schemaQueryOptions)),
     Effect.withSpan('Database.schemaQuery'),
@@ -347,7 +350,7 @@ export const schemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Qu
  */
 export const runSchemaQuery = <Q extends Types.NoExcessProperties<SchemaRegistry.Query, Q>>(
   schemaQueryOptions?: Q & SchemaRegistry.Query,
-): Effect.Effect<SchemaRegistry.ExtractQueryResult<Q>[], never, Service> =>
+): Effect.Effect<Type.Type[], never, Service> =>
   schemaQuery(schemaQueryOptions).pipe(
     Effect.flatMap((queryResult) => promiseWithCauseCapture(() => queryResult.run())),
   );

package/src/Dataset.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import { pipe } from 'effect/Function';
+import * as Predicate from 'effect/Predicate';
+import * as Schema from 'effect/Schema';
+
+import * as Collection from './Collection';
+import * as Feed from './Feed';
+import * as Obj from './Obj';
+import * as Type from './Type';
+import * as View from './View';
+
+/**
+ * Abstract set of objects, represented by a view, feed, or collection.
+ * Schema-level union of the underlying type entities (rebuilt via
+ * `Type.getSchema`) so this can still be consumed by Schema-side APIs such
+ * as `Filter.type(...)` on a union.
+ */
+export type Dataset = Feed.Feed | Collection.Collection | View.View;
+export const Dataset = Schema.Union(
+  Type.getSchema(Feed.Feed),
+  Type.getSchema(Collection.Collection),
+  Type.getSchema(View.View),
+);
+
+export const isDataset: (value: unknown) => value is Dataset = pipe(
+  Obj.instanceOf(Feed.Feed),
+  Predicate.or(Obj.instanceOf(Collection.Collection)),
+  Predicate.or(Obj.instanceOf(View.View)),
+);

package/src/Entity.test.ts

@@ -4,19 +4,129 @@
 
 import { describe, expect, test } from 'vitest';
 
-import type * as Entity from './Entity';
+import * as Entity from './Entity';
 import * as Obj from './Obj';
 import * as Relation from './Relation';
 import { TestSchema } from './testing';
+import * as Type from './Type';
+
+const makeObject = () =>
+  Obj.make(TestSchema.Person, {
+    name: 'Test',
+    username: 'test',
+    email: 'test@example.com',
+    tasks: [],
+  });
+
+const makeRelation = (obj: TestSchema.Person) =>
+  Relation.make(TestSchema.HasManager, { [Relation.Source]: obj, [Relation.Target]: obj });
 
 describe('Entity', () => {
   test('Entity.Unknown accepts any object or relation', () => {
-    const obj = Obj.make(TestSchema.Person, { name: 'Test' });
-    const rel = Relation.make(TestSchema.HasManager, { [Relation.Source]: obj, [Relation.Target]: obj });
-    const doSomething = (entity: Entity.Unknown) => {
-      return entity;
-    };
+    const obj = makeObject();
+    const rel = makeRelation(obj);
+    const doSomething = (entity: Entity.Unknown) => entity;
     expect(doSomething(obj)).toBe(obj);
     expect(doSomething(rel)).toBe(rel);
   });
+
+  // `isEntity` is a bare brand check (`[KindId] !== undefined`). All three entity
+  // kinds — objects, relations, and type entities — carry the brand, so all three
+  // are recognised as entities. (Type entities brand with `EntityKind.Type`.)
+  describe('isEntity / isSnapshot', () => {
+    test('object instance is an entity', () => {
+      const obj = makeObject();
+      expect(Entity.isEntity(obj)).toBe(true);
+      expect(Entity.isSnapshot(obj)).toBe(false);
+    });
+
+    test('relation instance is an entity', () => {
+      const rel = makeRelation(makeObject());
+      expect(Entity.isEntity(rel)).toBe(true);
+      expect(Entity.isSnapshot(rel)).toBe(false);
+    });
+
+    test('type entity is an entity', () => {
+      expect(Entity.isEntity(TestSchema.Person)).toBe(true);
+      expect(Entity.isSnapshot(TestSchema.Person)).toBe(false);
+    });
+
+    test('non-entities are rejected', () => {
+      expect(Entity.isEntity(null)).toBe(false);
+      expect(Entity.isEntity({})).toBe(false);
+      expect(Entity.isEntity({ id: 'x' })).toBe(false);
+      expect(Entity.isEntity('string')).toBe(false);
+    });
+  });
+
+  // Object and relation instances behave identically across the Entity.* accessor
+  // surface: these accessors are written for runtime instances and read the
+  // instance's identity, type pointer and metadata.
+  describe.each([
+    ['object', () => makeObject(), 'com.example.type.person'],
+    ['relation', () => makeRelation(makeObject()), 'com.example.type.hasManager'],
+  ] as const)('instance accessors (%s)', (_label, make, typename) => {
+    test('getURI returns an echo URI', () => {
+      const entity = make();
+      expect(Entity.getURI(entity)).toMatch(/^echo:/);
+    });
+
+    test('getTypename returns the typename', () => {
+      expect(Entity.getTypename(make())).toBe(typename);
+    });
+
+    test('getTypeURI returns the type DXN', () => {
+      expect(Entity.getTypeURI(make())).toBe(`dxn:${typename}:0.1.0`);
+    });
+
+    test('getType resolves back to the type entity', () => {
+      const type = Entity.getType(make());
+      expect(type).toBeDefined();
+      expect(Type.getTypename(type!)).toBe(typename);
+    });
+
+    test('getMeta returns metadata', () => {
+      expect(Entity.getMeta(make())).toBeDefined();
+    });
+
+    test('isDeleted is false for a live entity', () => {
+      expect(Entity.isDeleted(make())).toBe(false);
+    });
+
+    test('toJSON serializes the entity', () => {
+      const json = Entity.toJSON(make());
+      expect(json).toMatchObject({ '@type': expect.stringContaining(typename) });
+    });
+  });
+
+  // Type entities are first-class entities: the Entity.* accessors work on them too.
+  // `getURI`/`getTypename` return the type's OWN identity, while `getType`/`getTypeURI`
+  // (which mean "the type this entity is an instance of") resolve to the meta-type
+  // `Type.Type`.
+  describe('type entity', () => {
+    test('isEntity / getMeta / isDeleted', () => {
+      expect(Entity.isEntity(TestSchema.Person)).toBe(true);
+      expect(Entity.getMeta(TestSchema.Person)).toBeDefined();
+      expect(Entity.isDeleted(TestSchema.Person)).toBe(false);
+    });
+
+    test('getURI / getTypename return the type entity’s own identity', () => {
+      expect(Entity.getURI(TestSchema.Person)).toBe('dxn:com.example.type.person:0.1.0');
+      expect(Entity.getTypename(TestSchema.Person)).toBe('com.example.type.person');
+    });
+
+    test('getType / getTypeURI resolve to the meta-type (Type.Type)', () => {
+      expect(Entity.getType(TestSchema.Person)).toBe(Type.Type);
+      expect(Entity.getTypeURI(TestSchema.Person)).toBe('dxn:org.dxos.type.schema:0.1.0');
+    });
+
+    test('Entity.* and Type.* agree on type identity', () => {
+      expect(Entity.getURI(TestSchema.Person)).toBe(Type.getURI(TestSchema.Person));
+      expect(Entity.getTypename(TestSchema.Person)).toBe(Type.getTypename(TestSchema.Person));
+      expect(Type.isType(TestSchema.Person)).toBe(true);
+      expect(Type.isObject(TestSchema.Person)).toBe(true);
+      expect(Type.isRelation(TestSchema.HasManager)).toBe(true);
+      expect(Type.getVersion(TestSchema.Person)).toBe('0.1.0');
+    });
+  });
 });