@dxos/echo 0.9.1-main.c7dcc2e112 → 0.9.1-staging.ee54ba693a

package/src/Text.test.ts

@@ -0,0 +1,186 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import * as Obj from './Obj';
+import { TestSchema } from './testing';
+import * as Text from './Text';
+
+describe('Text', () => {
+  describe('update', () => {
+    test('replaces the value; readable via getValue', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      Obj.update(obj, () => {
+        Text.update(obj, 'name', 'goodbye');
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('goodbye');
+    });
+
+    test('accepts a key-path array', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      Obj.update(obj, () => {
+        Text.update(obj, ['name'], 'world');
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('world');
+    });
+
+    test('updates a nested string field', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'a', address: { city: 'Paris', coordinates: {} } });
+      Obj.update(obj, () => {
+        Text.update(obj, ['address', 'city'], 'London');
+      });
+      expect(Obj.getValue(obj, ['address', 'city'])).toBe('London');
+    });
+  });
+
+  describe('splice', () => {
+    test('inserts at an index', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'helloworld' });
+      Obj.update(obj, () => {
+        const removed = Text.splice(obj, 'name', 5, 0, ' ');
+        expect(removed).toBe('');
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('hello world');
+    });
+
+    test('deletes and returns the removed substring', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello world' });
+      Obj.update(obj, () => {
+        const removed = Text.splice(obj, 'name', 5, 6);
+        expect(removed).toBe(' world');
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('hello');
+    });
+
+    test('replaces in place', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello world' });
+      Obj.update(obj, () => {
+        const removed = Text.splice(obj, 'name', 6, 5, 'there');
+        expect(removed).toBe('world');
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('hello there');
+    });
+
+    test('start past end appends', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'abc' });
+      Obj.update(obj, () => {
+        const removed = Text.splice(obj, 'name', 100, 0, 'def');
+        expect(removed).toBe('');
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('abcdef');
+    });
+
+    test('mirrors Array.splice index semantics', ({ expect }) => {
+      const reference = 'hello world';
+      const obj = Obj.make(TestSchema.Person, { name: reference });
+      let removed = '';
+      Obj.update(obj, () => {
+        removed = Text.splice(obj, 'name', 0, 5, 'HELLO');
+      });
+      // Mirror the same operation on a character array.
+      const chars = [...reference];
+      const removedChars = chars.splice(0, 5, ...'HELLO');
+      expect(removed).toBe(removedChars.join(''));
+      expect(Obj.getValue(obj, ['name'])).toBe(chars.join(''));
+    });
+  });
+
+  describe('apply', () => {
+    test('replaces the first occurrence', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'foo foo foo' });
+      Obj.update(obj, () => {
+        Text.apply(obj, 'name', [{ oldString: 'foo', newString: 'bar' }]);
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('bar foo foo');
+    });
+
+    test('replaces all occurrences', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'foo foo foo' });
+      Obj.update(obj, () => {
+        Text.apply(obj, 'name', [{ oldString: 'foo', newString: 'bar', replaceAll: true }]);
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('bar bar bar');
+    });
+
+    test('replaceAll does not re-match inserted text', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'a a a' });
+      Obj.update(obj, () => {
+        Text.apply(obj, 'name', [{ oldString: 'a', newString: 'aa', replaceAll: true }]);
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('aa aa aa');
+    });
+
+    test('appends when oldString is missing', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      Obj.update(obj, () => {
+        Text.apply(obj, 'name', [{ newString: ' world' }]);
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('hello world');
+    });
+
+    test('appends when oldString is empty', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      Obj.update(obj, () => {
+        Text.apply(obj, 'name', [{ oldString: '', newString: '!' }]);
+      });
+      expect(Obj.getValue(obj, ['name'])).toBe('hello!');
+    });
+
+    test('applies edits sequentially and returns the final text', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      let result = '';
+      Obj.update(obj, () => {
+        result = Text.apply(obj, 'name', [{ oldString: 'hello', newString: 'hi' }, { newString: ' there' }]);
+      });
+      expect(result).toBe('hi there');
+      expect(Obj.getValue(obj, ['name'])).toBe('hi there');
+    });
+
+    test('throws when a non-replaceAll oldString is not found', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      expect(() =>
+        Obj.update(obj, () => {
+          Text.apply(obj, 'name', [{ oldString: 'missing', newString: 'x' }]);
+        }),
+      ).toThrow();
+    });
+  });
+
+  describe('strict mode', () => {
+    test('update throws outside Obj.update', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      expect(() => Text.update(obj, 'name', 'x')).toThrow(/Obj\.update/);
+    });
+
+    test('splice throws outside Obj.update', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      expect(() => Text.splice(obj, 'name', 0, 1, 'x')).toThrow(/Obj\.update/);
+    });
+
+    test('apply throws outside Obj.update', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      expect(() => Text.apply(obj, 'name', [{ oldString: 'h', newString: 'H' }])).toThrow(/Obj\.update/);
+    });
+  });
+
+  describe('reactivity', () => {
+    test('a subscriber fires once per Obj.update batch', ({ expect }) => {
+      const obj = Obj.make(TestSchema.Person, { name: 'hello' });
+      let count = 0;
+      const unsubscribe = Obj.subscribe(obj, () => {
+        count++;
+      });
+
+      Obj.update(obj, () => {
+        Text.splice(obj, 'name', 0, 5, 'goodbye');
+        Text.splice(obj, 'name', 0, 0, '!');
+      });
+
+      expect(count).toBe(1);
+      expect(Obj.getValue(obj, ['name'])).toBe('!goodbye');
+      unsubscribe();
+    });
+  });
+});

package/src/Text.ts

@@ -0,0 +1,116 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Err from './Err';
+import * as internal from './internal';
+import * as Obj from './Obj';
+
+/**
+ * A key path addressing a string value within an object, mirroring `Obj.getValue` / `Obj.setValue`.
+ */
+export type KeyPath = readonly (string | number)[];
+
+/**
+ * A single find/replace edit applied to a string field. When `oldString` is missing or empty the
+ * `newString` is appended to the end of the current value.
+ */
+export type Edit = {
+  oldString?: string;
+  newString: string;
+  replaceAll?: boolean;
+};
+
+/**
+ * Replace the string CRDT value at `path` with `newText`.
+ *
+ * For database-backed objects the change is applied as a minimal Automerge diff (preserving cursors,
+ * anchors, and merging cleanly with concurrent edits); for in-memory objects it is a plain assignment.
+ *
+ * Must be called inside `Obj.update(obj, () => { ... })`.
+ */
+export const update = (obj: Obj.Unknown, path: KeyPath | string | number, newText: string): void => {
+  const { handler, target } = resolve(obj, 'update');
+  if (typeof handler.textUpdate !== 'function') {
+    throw new Err.TextNotSupportedError('update');
+  }
+  handler.textUpdate(target, normalizePath(path), newText);
+};
+
+/**
+ * Splice the string CRDT value at `path` by character index, mirroring `Array.prototype.splice`:
+ * remove `deleteCount` characters at `start` and insert `insert`. Returns the removed substring.
+ *
+ * Must be called inside `Obj.update(obj, () => { ... })`.
+ */
+export const splice = (
+  obj: Obj.Unknown,
+  path: KeyPath | string | number,
+  start: number,
+  deleteCount: number,
+  insert = '',
+): string => {
+  const { handler, target } = resolve(obj, 'splice');
+  if (typeof handler.textSplice !== 'function') {
+    throw new Err.TextNotSupportedError('splice');
+  }
+  return handler.textSplice(target, normalizePath(path), start, deleteCount, insert);
+};
+
+/**
+ * Apply a sequence of find/replace {@link Edit}s to the string value at `path`, returning the resulting
+ * full string. Implemented on top of {@link splice} so it works for both backends.
+ *
+ * An edit with a missing or empty `oldString` appends its `newString`. A non-`replaceAll` edit whose
+ * `oldString` is not found throws {@link Err.TextEditNotFoundError}.
+ *
+ * Must be called inside `Obj.update(obj, () => { ... })`.
+ */
+export const apply = (obj: Obj.Unknown, path: KeyPath | string | number, edits: readonly Edit[]): string => {
+  const keyPath = normalizePath(path);
+  for (const edit of edits) {
+    const text: string = Obj.getValue(obj, keyPath) ?? '';
+    if (edit.oldString == null || edit.oldString.length === 0) {
+      // Append: an empty match would loop forever in `replaceAll`, so treat it as an append instead.
+      splice(obj, keyPath, text.length, 0, edit.newString);
+      continue;
+    }
+
+    if (edit.replaceAll) {
+      let idx = text.indexOf(edit.oldString);
+      while (idx !== -1) {
+        splice(obj, keyPath, idx, edit.oldString.length, edit.newString);
+        const updated: string = Obj.getValue(obj, keyPath) ?? '';
+        // Resume past the inserted text so a `newString` that contains `oldString` is not re-matched.
+        idx = updated.indexOf(edit.oldString, idx + edit.newString.length);
+      }
+    } else {
+      const idx = text.indexOf(edit.oldString);
+      if (idx === -1) {
+        throw new Err.TextEditNotFoundError(edit.oldString);
+      }
+      splice(obj, keyPath, idx, edit.oldString.length, edit.newString);
+    }
+  }
+
+  return Obj.getValue(obj, keyPath) ?? '';
+};
+
+const normalizePath = (path: KeyPath | string | number): KeyPath =>
+  typeof path === 'string' || typeof path === 'number' ? [path] : path;
+
+/**
+ * Resolve the reactive handler and raw target for `obj`. The handler is shared between the in-memory
+ * and database-backed proxy systems, so this is the single dispatch seam for both backends. Snapshots
+ * and non-reactive values are not proxies and cannot be edited.
+ */
+const resolve = (obj: Obj.Unknown, operation: string) => {
+  if (!internal.isProxy(obj)) {
+    throw new Err.TextNotSupportedError(operation);
+  }
+  const handler = internal.getProxyHandler(obj);
+  const target = internal.getProxyTarget(obj);
+  return { handler, target };
+};

package/src/Type.test.ts

@@ -8,8 +8,10 @@ import { describe, test } from 'vitest';
 import { DXN, EntityId } from '@dxos/keys';
 
 import * as Entity from './Entity';
+import * as Filter from './Filter';
 import * as JsonSchema from './JsonSchema';
 import * as Obj from './Obj';
+import * as Ref from './Ref';
 import * as Relation from './Relation';
 import { TestSchema } from './testing';
 import * as Type from './Type';
@@ -205,53 +207,79 @@ describe('Type', () => {
     const worksForDxn = DXN.make('com.example.type.deterministic.worksFor', '0.1.0');
 
     test('Type.makeObject with the same DXN twice yields entities with identical ids', ({ expect }) => {
-      const a = Schema.Struct({ name: Schema.String }).pipe(Type.makeObject(personDxn));
-      const b = Schema.Struct({ name: Schema.String }).pipe(Type.makeObject(personDxn));
+      const a = Type.makeObject(personDxn)(Schema.Struct({ name: Schema.String }));
+      const b = Type.makeObject(personDxn)(Schema.Struct({ name: Schema.String }));
       expect(a.id).toBe(b.id);
       expect(a.id).toBe(EntityId.deterministic('com.example.type.deterministic.person', '0.1.0'));
     });
 
     test('different versions produce different ids', ({ expect }) => {
-      const v1 = Schema.Struct({ name: Schema.String }).pipe(
-        Type.makeObject(DXN.make('com.example.type.deterministic.person', '0.1.0')),
+      const v1 = Type.makeObject(DXN.make('com.example.type.deterministic.person', '0.1.0'))(
+        Schema.Struct({ name: Schema.String }),
       );
-      const v2 = Schema.Struct({ name: Schema.String }).pipe(
-        Type.makeObject(DXN.make('com.example.type.deterministic.person', '0.2.0')),
+      const v2 = Type.makeObject(DXN.make('com.example.type.deterministic.person', '0.2.0'))(
+        Schema.Struct({ name: Schema.String }),
       );
       expect(v1.id).not.toBe(v2.id);
     });
 
     test('Type.makeObject({ id }) override is honoured', ({ expect }) => {
       const explicit = EntityId.random();
-      const entity = Schema.Struct({ name: Schema.String }).pipe(Type.makeObject(personDxn, { id: explicit }));
+      const entity = Type.makeObject(personDxn, { id: explicit })(Schema.Struct({ name: Schema.String }));
       expect(entity.id).toBe(explicit);
       // And the default still kicks in when no override is supplied.
-      const defaultEntity = Schema.Struct({ name: Schema.String }).pipe(Type.makeObject(personDxn));
+      const defaultEntity = Type.makeObject(personDxn)(Schema.Struct({ name: Schema.String }));
       expect(defaultEntity.id).not.toBe(explicit);
     });
 
     test('Type.makeRelation defaults id to deterministic(typename, version)', ({ expect }) => {
-      const a = Schema.Struct({ since: Schema.Number }).pipe(
-        Type.makeRelation({ dxn: worksForDxn, source: TestSchema.Person, target: TestSchema.Organization }),
-      );
-      const b = Schema.Struct({ since: Schema.Number }).pipe(
-        Type.makeRelation({ dxn: worksForDxn, source: TestSchema.Person, target: TestSchema.Organization }),
-      );
-      expect(a.id).toBe(b.id);
-      expect(a.id).toBe(EntityId.deterministic('com.example.type.deterministic.worksFor', '0.1.0'));
+      class RelationA extends Type.makeRelation<RelationA>(worksForDxn)({
+        source: TestSchema.Person,
+        target: TestSchema.Organization,
+      })(Schema.Struct({ since: Schema.Number })) {}
+
+      class RelationB extends Type.makeRelation<RelationB>(worksForDxn)({
+        source: TestSchema.Person,
+        target: TestSchema.Organization,
+      })(Schema.Struct({ since: Schema.Number })) {}
+
+      expect(RelationA.id).toBe(RelationB.id);
+      expect(RelationA.id).toBe(EntityId.deterministic('com.example.type.deterministic.worksFor', '0.1.0'));
     });
 
     test('Type.makeRelation({ id }) override is honoured', ({ expect }) => {
       const explicit = EntityId.random();
-      const entity = Schema.Struct({ since: Schema.Number }).pipe(
-        Type.makeRelation({
-          dxn: worksForDxn,
-          source: TestSchema.Person,
-          target: TestSchema.Organization,
-          id: explicit,
-        }),
-      );
+      const entity = Type.makeRelation(worksForDxn)({
+        source: TestSchema.Person,
+        target: TestSchema.Organization,
+        id: explicit,
+      })(Schema.Struct({ since: Schema.Number }));
       expect(entity.id).toBe(explicit);
     });
+
+    test('Type.makeObject class syntax', ({ expect }) => {
+      class Person extends Type.makeObject<Person>(DXN.make('com.example.type.person', '0.1.0'))(
+        Schema.Struct({ name: Schema.String }),
+      ) {}
+      expect(Person.jsonSchema).toBeDefined();
+    });
+
+    test('Ref of Type.makeObject class', ({ expect }) => {
+      class Person extends Type.makeObject<Person>(DXN.make('com.example.type.person', '0.1.0'))(
+        Schema.Struct({ name: Schema.String }),
+      ) {}
+
+      const refSchema = Ref.Ref(Person);
+      expect(refSchema).toBeDefined();
+    });
+
+    test('Filter of Type.makeObject class', ({ expect }) => {
+      class Person extends Type.makeObject<Person>(DXN.make('com.example.type.person', '0.1.0'))(
+        Schema.Struct({ name: Schema.String }),
+      ) {}
+
+      const filter = Filter.type(Person);
+      expect(filter).toBeDefined();
+    });
   });
 });

package/src/Type.ts

@@ -73,11 +73,9 @@ interface BaseTypeEntity<A> {
  *
  * @example
  * ```ts
- * const Person = Schema.Struct({
- *   name: Schema.String,
- * }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
- *
- * type Person = Type.InstanceType<typeof Person>;
+ * class Person extends Type.makeObject<Person>(DXN.make('com.example.type.person', '0.1.0'))(
+ *   Schema.Struct({ name: Schema.String }),
+ * ) {}
  * ```
  */
 export interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fields> extends BaseTypeEntity<
@@ -96,6 +94,15 @@ export interface Obj<T, Fields extends Schema.Struct.Fields = Schema.Struct.Fiel
   readonly fields: Fields;
 }
 
+/**
+ * Return type for {@link makeObject}.
+ *
+ * Not to be used directly, but must be exported for typescript to infer the type.
+ */
+export interface ObjClass<Self, T, Fields extends Schema.Struct.Fields> extends Obj<Self, Fields> {
+  new (_: never): T & EntityModule.OfKind<typeof EntityModule.Kind.Object>;
+}
+
 /**
  * Type that represents any ECHO object type — a `Type.Type` entity branded
  * with the object entity kind, i.e. what `Type.makeObject(dxn)` produces.
@@ -115,19 +122,26 @@ export type AnyObj = Obj<unknown>;
  * scope. Pass `{ id }` to override (e.g. with `EntityId.random()` from a
  * request handler).
  *
+ * Giving the type a nominal class name keeps its inferred type portable for
+ * declaration emit: structural expansion (which can pull in unnameable union
+ * members from referenced schemas) is replaced by a reference to the class.
+ *
  * @example
  * ```ts
- * const Person = Schema.Struct({
+ * export class Person extends Type.makeObject<Person>(DXN.make('com.example.type.myType', '0.1.0'))(Schema.Struct({
  *   name: Schema.String,
- * }).pipe(Type.makeObject(DXN.make('com.example.type.person', '0.1.0')));
+ * })) {}
  * ```
  */
+// TODO(burdon): Require { typename, version } in options.
 export const makeObject: {
-  (
+  <Self>(
     dxn: DXN.DXN,
     options?: { id?: EntityId },
-  ): <Self extends Schema.Schema.Any>(self: Self) => Obj<Schema.Schema.Type<Self>>;
-} = internal.EchoObjectSchema as any;
+  ): <_Schema extends Schema.Schema.Any>(schema: _Schema) => ObjClass<Self, Schema.Schema.Type<_Schema>, {}>;
+  // Boundary cast: overload implementation bodies cannot access outer generic params (`Self`),
+  // so TypeScript cannot verify that makeObjectType's return matches the declared ObjClass<Self,…>.
+} = (dxn, options) => (schema) => internal.makeObjectType(dxn, schema, options) as any;
 
 //
 // Type — the ECHO entity that holds a schema and metadata.
@@ -255,6 +269,20 @@ export interface Relation<
   readonly fields: Fields;
 }
 
+/**
+ * Return type for {@link makeRelation}.
+ *
+ * Not to be used directly, but must be exported for typescript to infer the type.
+ */
+export interface RelationClass<Self, T, Source, Target, Fields extends Schema.Struct.Fields> extends Relation<
+  Self,
+  Source,
+  Target,
+  Fields
+> {
+  new (_: never): RelationModule.Endpoints<Source, Target> & T & EntityModule.OfKind<typeof EntityModule.Kind.Relation>;
+}
+
 /**
  * Type that represents any ECHO relation type — a `Type.Type` entity branded
  * with the relation entity kind, i.e. what `Type.makeRelation(...)` produces.
@@ -267,18 +295,13 @@ export type AnyRelation = Relation<unknown, unknown, unknown>;
  *
  * @example
  * ```ts
- * const WorksFor = Schema.Struct({
- *   role: Schema.String,
- * }).pipe(Type.makeRelation({
- *   dxn: DXN.make('com.example.type.worksFor', '0.1.0'),
- *   source: Person,
- *   target: Company,
- * }));
+ * class WorksFor extends Type.makeRelation<WorksFor>(DXN.make('com.example.type.worksFor', '0.1.0'))(
+ *   { source: Person, target: Company },
+ * )(Schema.Struct({ role: Schema.String })) {}
  * ```
  */
 export const makeRelation: {
-  <SourceInstance, TargetInstance>(opts: {
-    dxn: DXN.DXN;
+  <Self>(dxn: DXN.DXN): <SourceInstance, TargetInstance>(opts: {
     source: Obj<SourceInstance, any> | internal.UnknownTypeSchema<SourceInstance, typeof EntityModule.Kind.Object>;
     target: Obj<TargetInstance, any> | internal.UnknownTypeSchema<TargetInstance, typeof EntityModule.Kind.Object>;
     /**
@@ -286,14 +309,25 @@ export const makeRelation: {
      * see `Type.makeObject` for the workerd motivation.
      */
     id?: EntityId;
-  }): <Self extends Schema.Schema.Any>(
-    self: Self,
-  ) => Relation<
-    Schema.Schema.Type<Self>,
+  }) => <_Schema extends Schema.Schema.Any>(
+    schema: _Schema,
+  ) => RelationClass<
+    Self,
+    Schema.Schema.Type<_Schema>,
     SourceInstance & EntityModule.OfKind<typeof EntityModule.Kind.Object>,
-    TargetInstance & EntityModule.OfKind<typeof EntityModule.Kind.Object>
+    TargetInstance & EntityModule.OfKind<typeof EntityModule.Kind.Object>,
+    {}
   >;
-} = internal.EchoRelationSchema as any;
+} = (dxn) => (opts) => (schema) =>
+  // Boundary cast: makeRelationType erases generic params since the constructor/prototype
+  // wiring cannot thread them through the type system.
+  internal.makeRelationType({
+    dxn,
+    source: opts.source,
+    target: opts.target,
+    schema,
+    id: opts.id,
+  }) as any;
 
 /**
  * Type that represents any ECHO type-kind entity — a `Type.Type` meta-schema
@@ -611,13 +645,17 @@ export interface Type<A = unknown> extends BaseTypeEntity<A & EntityModule.OfKin
  *  - `Type<A>`               → `A & OfKind<Type>`
  */
 export type InstanceType<T extends AnyEntity> =
-  T extends Relation<infer Props, infer Source, infer Target, any>
+  T extends RelationClass<any, infer Props, infer Source, infer Target, any>
     ? RelationModule.Endpoints<Source, Target> & Props & EntityModule.OfKind<typeof EntityModule.Kind.Relation>
-    : T extends Obj<infer A, any>
-      ? A & EntityModule.OfKind<typeof EntityModule.Kind.Object>
-      : T extends Type<infer A>
-        ? A & EntityModule.OfKind<typeof EntityModule.Kind.Type>
-        : never;
+    : T extends Relation<infer Props, infer Source, infer Target, any>
+      ? RelationModule.Endpoints<Source, Target> & Props & EntityModule.OfKind<typeof EntityModule.Kind.Relation>
+      : T extends ObjClass<any, infer A, any>
+        ? A & EntityModule.OfKind<typeof EntityModule.Kind.Object>
+        : T extends Obj<infer A, any>
+          ? A & EntityModule.OfKind<typeof EntityModule.Kind.Object>
+          : T extends Type<infer A>
+            ? A & EntityModule.OfKind<typeof EntityModule.Kind.Type>
+            : never;
 
 /**
  * Returns the Effect Schema for a type entity.

package/src/View.ts

@@ -60,36 +60,28 @@ export type Projection = Schema.Schema.Type<typeof Projection>;
  * Views are generated or user-defined projections of a schema's properties.
  * They are used to configure the visual representation of the data.
  */
-const ViewSchema = Schema.Struct({
-  /**
-   * Query used to retrieve data.
-   * Can be a user-provided query grammar string or a query AST.
-   */
-  query: Schema.Struct({
-    raw: Schema.optional(Schema.String),
-    ast: QueryAST.Query,
-  }),
-
-  /**
-   * Projection of the data returned from the query.
-   */
-  projection: Projection,
-}).pipe(
-  internal.HiddenAnnotation.set(true),
-  Annotation.IconAnnotation.set({ icon: 'ph--funnel--regular', hue: 'green' }),
-  Type.makeObject(DXN.make('org.dxos.type.view', '0.1.0')),
-);
-
-// NOTE: Declared as a named interface and the `View` const is annotated `Type.Obj<View>` so
-//   downstream consumers see a named `View` type instead of the inlined `QueryAST.Query` union.
-//   Without the named interface, embedding `Type.getSchema(View.View)` in a downstream
-//   `Schema.Struct` triggers TS2742 portability errors (e.g. plugin-kanban, plugin-table).
-// TODO(wittjosiah): Find a better solution that doesn't require manually keeping the interface in sync.
-export interface View extends Type.InstanceType<typeof ViewSchema> {}
-
-export const View: Type.Obj<View> = ViewSchema as any;
-
-export const make = (props: Partial<Obj.MakeProps<typeof View>>): View => {
+export class View extends Type.makeObject<View>(DXN.make('org.dxos.type.view', '0.1.0'))(
+  Schema.Struct({
+    /**
+     * Query used to retrieve data.
+     * Can be a user-provided query grammar string or a query AST.
+     */
+    query: Schema.Struct({
+      raw: Schema.optional(Schema.String),
+      ast: QueryAST.Query,
+    }),
+
+    /**
+     * Projection of the data returned from the query.
+     */
+    projection: Projection,
+  }).pipe(
+    internal.HiddenAnnotation.set(true),
+    Annotation.IconAnnotation.set({ icon: 'ph--funnel--regular', hue: 'green' }),
+  ),
+) {}
+
+export const make = (props: Partial<Obj.MakeProps<typeof View>>): Type.InstanceType<typeof View> => {
   return Obj.make(View, {
     query: { ast: Query.select(Filter.nothing()).ast },
     projection: { fields: [] },

package/src/index.ts

@@ -8,7 +8,6 @@ export { DXN, EID, URI } from '@dxos/keys';
 export * as Annotation from './Annotation';
 export * as Database from './Database';
 export * as Entity from './Entity';
-// TODO(burdon): Rename to Error (less problematic than Obj/Object).
 export * as Err from './Err';
 export * as Feed from './Feed';
 export * as Filter from './Filter';
@@ -27,6 +26,7 @@ export * as Registry from './Registry';
 export * as Relation from './Relation';
 export * as Scope from './Scope';
 export * as Tag from './Tag';
+export * as Text from './Text';
 export * as Type from './Type';
 export * as Collection from './Collection';
 export * as View from './View';