@dxos/echo 0.8.4-main.70d3990 → 0.8.4-main.74a063c4e0

package/src/internal/{annotations → Annotation}/annotations.ts

@@ -7,15 +7,15 @@ import * as Option from 'effect/Option';
 import * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
 
-import { Reference } from '@dxos/echo-protocol';
+import { raise } from '@dxos/debug';
 import { type JsonPath, getField } from '@dxos/effect';
 import { assertArgument, invariant } from '@dxos/invariant';
 import { DXN } from '@dxos/keys';
 import { type Primitive } from '@dxos/util';
 
-import { type AnyProperties, EntityKind, TypeId, getSchema } from '../types';
-
-import { createAnnotationHelper } from './util';
+import { type Mutable } from '../common/proxy';
+import { type AnyProperties, EntityKind, TypeId, getSchema } from '../common/types';
+import { type AnnotationHelper, createAnnotationHelper } from './util';
 
 /**
  * @internal
@@ -29,6 +29,10 @@ export const FIELD_PATH_ANNOTATION = 'path';
 // TODO(burdon): Field, vs. path vs. property.
 export const FieldPath = (path: string) => PropertyMeta(FIELD_PATH_ANNOTATION, path);
 
+//
+// Type
+//
+
 /**
  * ECHO identifier (for a stored schema).
  * Must be a `dxn:echo:` URI.
@@ -41,18 +45,59 @@ export const getTypeIdentifierAnnotation = (schema: Schema.Schema.All) =>
     Option.getOrElse(() => undefined),
   )(schema.ast);
 
+/**
+ * @returns DXN of the schema.
+ *
+ * For non-stored schema returns `dxn:type:`.
+ * For stored schema returns `dxn:echo:`.
+ */
+export const getSchemaDXN = (schema: Schema.Schema.All): DXN | undefined => {
+  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');
+  const id = getTypeIdentifierAnnotation(schema);
+  if (id) {
+    return DXN.parse(id);
+  }
+
+  // TODO(dmaretskyi): Add support for dynamic schema.
+  const objectAnnotation = getTypeAnnotation(schema);
+  if (!objectAnnotation) {
+    return undefined;
+  }
+
+  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);
+};
+
+/**
+ * @param input schema or a typename string.
+ * @return type DXN.
+ */
+export const getTypeDXNFromSpecifier = (input: Schema.Schema.All | string): DXN => {
+  if (Schema.isSchema(input)) {
+    return getSchemaDXN(input) ?? raise(new TypeError('Schema has no DXN'));
+  } else {
+    assertArgument(typeof input === 'string', 'input');
+    assertArgument(!input.startsWith('dxn:'), 'input');
+    return DXN.fromTypename(input);
+  }
+};
+
+//
+// TypeAnnotation
+//
+
 /**
  * Fully qualified globally unique typename.
- * Example: `dxos.org/type/Person`
- */
-// TODO(burdon): Reconcile with short DXN format.
-// TODO(burdon): Change type => schema throughout.
-export const TypenameSchema = Schema.String.pipe(Schema.pattern(/^[a-zA-Z]\w+\.[a-zA-Z]\w{1,}\/[\w/_-]+$/)).annotations(
-  {
-    description: 'Fully qualified globally unique typename',
-    example: 'dxos.org/type/Person',
-  },
-);
+ * Example: `org.dxos.type.message`
+ */
+// TODO(wittjosiah): Factor out to DXN spec.
+// TODO(wittjosiah): Switch to atproto NSID regex once legacy typenames are fully migrated:
+//   /^[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(\.[a-zA-Z]([a-zA-Z0-9]{0,62})?)$/
+export const TypenameSchema = Schema.String.pipe(
+  Schema.pattern(/^[a-zA-Z][a-zA-Z0-9]*(\.[a-zA-Z][a-zA-Z0-9-]*){2,}$/),
+).annotations({
+  description: 'Fully qualified globally unique typename in reverse-DNS form.',
+  example: 'org.dxos.type.message',
+});
 
 /**
  * Semantic version format: `major.minor.patch`
@@ -82,9 +127,6 @@ export const TypeAnnotation = Schema.extend(
   TypeMeta,
   Schema.Struct({
     kind: Schema.Enums(EntityKind),
-    // kind: Schema.Enums(EntityKind),
-    // typename: Typename,
-    // version: VersionSchema,
 
     /**
      * If this is a relation, the schema of the source object.
@@ -102,8 +144,6 @@ export const TypeAnnotation = Schema.extend(
 
 export interface TypeAnnotation extends Schema.Schema.Type<typeof TypeAnnotation> {}
 
-// export type TypeMeta = Pick<TypeAnnotation, 'typename' | 'version'>;
-
 /**
  * @returns {@link TypeAnnotation} from a schema.
  * Schema must have been created with {@link TypedObject} or {@link TypedLink} or manually assigned an appropriate annotation.
@@ -136,7 +176,7 @@ export const getSchemaVersion = (schema: Schema.Schema.All): string | undefined
 /**
  * Gets the typename of the object without the version.
  * Returns only the name portion, not the DXN.
- * @example "example.org/type/Contact"
+ * @example "org.example.type.contact"
  *
  * @internal (use Obj.getTypename)
  */
@@ -168,7 +208,7 @@ export const setTypename = (obj: any, typename: DXN): void => {
 /**
  * @returns Object type as {@link DXN}.
  * @returns undefined if the object doesn't have a type.
- * @example `dxn:example.com/type/Person:1.0.0`
+ * @example `dxn:com.example.type.person:1.0.0`
  *
  * @internal (use Obj.getTypeDXN)
  */
@@ -228,6 +268,10 @@ export const isInstanceOf = <Schema extends Schema.Schema.AnyNoContext>(
   return typeDXN.type === typename;
 };
 
+//
+// PropertyMeta
+//
+
 /**
  * PropertyMeta (metadata for dynamic schema properties).
  * For user-defined annotations.
@@ -261,18 +305,16 @@ export const getPropertyMetaAnnotation = <T>(prop: SchemaAST.PropertySignature,
     Option.getOrElse(() => undefined),
   );
 
+//
+// Reference
+//
+
 /**
  * Schema reference.
  */
 export const ReferenceAnnotationId = Symbol.for('@dxos/schema/annotation/Reference');
-
 export type ReferenceAnnotationValue = TypeAnnotation;
-
-export const getReferenceAnnotation = (schema: Schema.Schema.AnyNoContext) =>
-  Function.pipe(
-    SchemaAST.getAnnotation<ReferenceAnnotationValue>(ReferenceAnnotationId)(schema.ast),
-    Option.getOrElse(() => undefined),
-  );
+export const ReferenceAnnotation = createAnnotationHelper<ReferenceAnnotationValue>(ReferenceAnnotationId);
 
 /**
  * SchemaMeta.
@@ -295,9 +337,14 @@ export const LabelAnnotation = createAnnotationHelper<string[]>(LabelAnnotationI
 
 /**
  * Returns the label for a given object based on {@link LabelAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
+ * Skips empty strings and whitespace-only strings, continuing to the next field.
  */
 // TODO(burdon): Convert to JsonPath?
-export const getLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.Schema.Type<S>): string | undefined => {
+export const getLabelWithSchema = <S extends Schema.Schema.Any>(
+  schema: S,
+  object: Schema.Schema.Type<S>,
+): string | undefined => {
   const annotation = LabelAnnotation.get(schema).pipe(Option.getOrElse(() => ['name']));
   for (const accessor of annotation) {
     assertArgument(
@@ -307,7 +354,13 @@ export const getLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.
     );
     const value = getField(object, accessor as JsonPath);
     switch (typeof value) {
-      case 'string':
+      case 'string': {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+          return value;
+        }
+        continue;
+      }
       case 'number':
       case 'boolean':
       case 'bigint':
@@ -325,8 +378,13 @@ export const getLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.
 
 /**
  * Sets the label for a given object based on {@link LabelAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
  */
-export const setLabel = <S extends Schema.Schema.Any>(schema: S, object: Schema.Schema.Type<S>, label: string) => {
+export const setLabelWithSchema = <S extends Schema.Schema.Any>(
+  schema: S,
+  object: Schema.Schema.Type<S>,
+  label: string,
+) => {
   const annotation = LabelAnnotation.get(schema).pipe(
     Option.map((field) => field[0]),
     Option.getOrElse(() => 'name'),
@@ -342,10 +400,11 @@ export const DescriptionAnnotationId = Symbol.for('@dxos/schema/annotation/Descr
 export const DescriptionAnnotation = createAnnotationHelper<string>(DescriptionAnnotationId);
 
 /**
- * Returns the label for a given object based on {@link LabelAnnotationId}.
+ * Returns the description for a given object based on {@link DescriptionAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
  */
 // TODO(burdon): Convert to JsonPath?
-export const getDescription = <S extends Schema.Schema.Any>(
+export const getDescriptionWithSchema = <S extends Schema.Schema.Any>(
   schema: S,
   object: Schema.Schema.Type<S>,
 ): string | undefined => {
@@ -369,8 +428,9 @@ export const getDescription = <S extends Schema.Schema.Any>(
 
 /**
  * Sets the description for a given object based on {@link DescriptionAnnotationId}.
+ * Lower-level version that requires explicit schema parameter.
  */
-export const setDescription = <S extends Schema.Schema.Any>(
+export const setDescriptionWithSchema = <S extends Schema.Schema.Any>(
   schema: S,
   object: Schema.Schema.Type<S>,
   description: string,
@@ -407,57 +467,112 @@ export type GeneratorAnnotationValue =
 
 export const GeneratorAnnotation = createAnnotationHelper<GeneratorAnnotationValue>(GeneratorAnnotationId);
 
+interface MakeAnnoationsProps<T> {
+  id: string;
+  schema: Schema.Schema<T, any, never>;
+}
+
+// TODO(wittjosiah): Comment.
+export const makeUserAnnotation = <T>(props: MakeAnnoationsProps<T>): AnnotationHelper<T> => {
+  assertArgument(
+    /^[a-z][a-z0-9]*(\.[a-z][a-z0-9-]*){2,}$/.test(props.id),
+    'id',
+    'Annotation id must be in the FQN format (org.dxos.annotation.example).',
+  );
+
+  const getFromAst = (ast: SchemaAST.AST) =>
+    SchemaAST.getAnnotation<PropertyMetaAnnotation>(PropertyMetaAnnotationId)(ast).pipe(
+      Option.map((meta) => meta[props.id] as unknown),
+      Option.map(Schema.decodeUnknownSync(props.schema)),
+    );
+
+  return {
+    get: (schema) => getFromAst(schema.ast),
+    getFromAst: (ast) => getFromAst(ast),
+    set: (value) =>
+      PropertyMeta(props.id, Schema.encodeSync(props.schema)(value)) as <S extends Schema.Schema.Any>(schema: S) => S,
+  };
+};
+
+const IconAnnotationSchema = Schema.Struct({
+  /**
+   * Phosphor icon name (e.g., 'ph--user--regular', 'ph--cube--regular', 'ph--link--regular ', etc.)
+   */
+  icon: Schema.String.pipe(Schema.pattern(/^ph--[a-z-]+--[a-z]+$/)),
+
+  /**
+   * Color name.
+   *
+   * List of colors:
+   *  - 'red'
+   *  - 'orange'
+   *  - 'amber'
+   *  - 'yellow'
+   *  - 'lime'
+   *  - 'green'
+   *  - 'emerald'
+   *  - 'teal'
+   *  - 'cyan'
+   *  - 'violet'
+   *  - 'purple'
+   *  - 'fuchsia'
+   *  - 'pink'
+   *  - 'rose'
+   */
+
+  hue: Schema.optional(Schema.String),
+});
+
+export interface IconAnnotation extends Schema.Schema.Type<typeof IconAnnotationSchema> {}
+
 /**
- * @returns DXN of the schema.
- *
- * For non-stored schema returns `dxn:type:`.
- * For stored schema returns `dxn:echo:`.
+ * Icon to render in the UI.
  */
-export const getSchemaDXN = (schema: Schema.Schema.All): DXN | undefined => {
-  assertArgument(Schema.isSchema(schema), 'schema', 'invalid schema');
-
-  const id = getTypeIdentifierAnnotation(schema);
-  if (id) {
-    return DXN.parse(id);
-  }
+export const IconAnnotation = makeUserAnnotation<IconAnnotation>({
+  id: 'org.dxos.annotation.icon',
+  schema: IconAnnotationSchema,
+});
 
-  // TODO(dmaretskyi): Add support for dynamic schema.
-  const objectAnnotation = getTypeAnnotation(schema);
-  if (!objectAnnotation) {
-    return undefined;
+/**
+ * Get the label of an entity.
+ * Accepts both reactive entities and snapshots.
+ */
+export const getLabel = (entity: AnyProperties): string | undefined => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getLabelWithSchema(schema, entity);
   }
-
-  return DXN.fromTypenameAndVersion(objectAnnotation.typename, objectAnnotation.version);
 };
 
 /**
- * Returns a reference that will be used to point to a schema.
- * @deprecated Use {@link getSchemaDXN} instead.
+ * Set the label of an entity.
+ * Must be called within an Obj.change or Relation.change callback.
  */
-export const getTypeReference = (schema: Schema.Schema.All | undefined): Reference | undefined => {
-  if (!schema) {
-    return undefined;
+export const setLabel = (entity: Mutable<AnyProperties>, label: string) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setLabelWithSchema(schema, entity, label);
   }
+};
 
-  const schemaDXN = getSchemaDXN(schema);
-  if (!schemaDXN) {
-    return undefined;
+/**
+ * Get the description of an entity.
+ * Accepts both reactive entities and snapshots.
+ */
+export const getDescription = (entity: AnyProperties): string | undefined => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    return getDescriptionWithSchema(schema, entity);
   }
-  return Reference.fromDXN(schemaDXN);
 };
 
 /**
- * Returns a reference that will be used to point to a schema.
- * @throws If it is not possible to reference this schema.
- *
- * @deprecated Use {@link getSchemaDXN} instead.
+ * Set the description of an entity.
+ * Must be called within an Obj.change or Relation.change callback.
  */
-export const requireTypeReference = (schema: Schema.Schema.AnyNoContext): Reference => {
-  const typeReference = getTypeReference(schema);
-  if (typeReference == null) {
-    // TODO(burdon): Catalog user-facing errors (this is too verbose).
-    throw new Error('Schema must be defined via TypedObject.');
+export const setDescription = (entity: Mutable<AnyProperties>, description: string) => {
+  const schema = getSchema(entity);
+  if (schema != null) {
+    setDescriptionWithSchema(schema, entity, description);
   }
-
-  return typeReference;
 };

package/src/internal/{annotations → Annotation}/index.ts

@@ -3,4 +3,5 @@
 //
 
 export * from './annotations';
+export * from './sorting';
 export * from './util';

package/src/internal/Annotation/sorting.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type { AnyEntity } from '../common/types';
+import { getLabel, getTypename } from './annotations';
+
+/**
+ * String comparison helper for sorting.
+ */
+export const compare = (a?: string, b?: string): number => {
+  if (a == null) {
+    return b == null ? 0 : 1;
+  }
+  if (b == null) {
+    return -1;
+  }
+  return a.localeCompare(b);
+};
+
+/**
+ * Comparator function type for sorting entities.
+ * Accepts both reactive entities and snapshots.
+ */
+export type Comparator<T extends AnyEntity = AnyEntity> = (a: T, b: T) => number;
+
+/**
+ * Sort entities by label.
+ */
+export const sortByLabel: Comparator = (a: AnyEntity, b: AnyEntity) => compare(getLabel(a), getLabel(b));
+
+/**
+ * Sort entities by typename.
+ */
+export const sortByTypename: Comparator = (a: AnyEntity, b: AnyEntity) => compare(getTypename(a), getTypename(b));
+
+/**
+ * Compose multiple comparators into one.
+ * Applies comparators in order until one returns non-zero.
+ */
+export const sort = <T extends AnyEntity>(...comparators: Comparator<T>[]): Comparator<T> => {
+  return (a: T, b: T) => {
+    for (const comparator of comparators) {
+      const result = comparator(a, b);
+      if (result !== 0) {
+        return result;
+      }
+    }
+    return 0;
+  };
+};

package/src/internal/{annotations → Annotation}/util.ts

@@ -9,16 +9,31 @@ import * as SchemaAST from 'effect/SchemaAST';
 import { assertArgument } from '@dxos/invariant';
 import { DXN } from '@dxos/keys';
 
-import { EntityKind } from '../types';
+import { EntityKind } from '../common/types';
 
 export interface AnnotationHelper<T> {
+  /**
+   * Get the annotation value from the schema.
+   */
   get: (schema: Schema.Schema.Any) => Option.Option<T>;
+  /**
+   * Get the annotation value from the AST.
+   */
+  getFromAst: (ast: SchemaAST.AST) => Option.Option<T>;
+  /**
+   * Set the annotation value on the schema.
+   */
   set: (value: T) => <S extends Schema.Schema.Any>(schema: S) => S;
 }
 
+/**
+ * Note: only for system annotations.
+ */
+// TODO(dmaretskyi): Rename to createSystemAnnotationHelper.
 export const createAnnotationHelper = <T>(id: symbol): AnnotationHelper<T> => {
   return {
     get: (schema) => SchemaAST.getAnnotation(schema.ast, id),
+    getFromAst: (ast) => SchemaAST.getAnnotation(ast, id),
     set:
       (value) =>
       <S extends Schema.Schema.Any>(schema: S) =>

package/src/internal/Entity/api.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+import { type DXN } from '@dxos/keys';
+import { assumeType } from '@dxos/util';
+
+import type { AnyEntity } from '../common/types';
+import { type InternalObjectProps, ObjectDatabaseId } from './model';
+import { getObjectDXN } from './util';
+
+/**
+ * Get the DXN of an entity.
+ * Accepts both reactive entities and snapshots.
+ */
+export const getDXN = (entity: AnyEntity): DXN => {
+  const dxn = getObjectDXN(entity);
+  invariant(dxn != null, 'Invalid entity.');
+  return dxn;
+};
+
+/**
+ * Get the database the entity belongs to.
+ * Accepts both reactive entities and snapshots.
+ */
+export const getDatabase = (entity: AnyEntity): any | undefined => {
+  assumeType<InternalObjectProps>(entity);
+  return entity[ObjectDatabaseId];
+};

package/src/internal/{entities → Entity}/entity.ts

@@ -8,34 +8,45 @@ import type * as Types from 'effect/Types';
 
 import { type ToMutable } from '@dxos/util';
 
-import { type TypeMeta } from '../annotations';
-import { type HasId } from '../types';
+import { type TypeMeta } from '../Annotation';
+import { type AnyEntity, type EntityKind, SchemaKindId } from '../common/types';
 
 // TODO(burdon): Define Schema type for `typename` and use consistently for all DXN-like properties.
 
 // type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
-export type EchoTypeSchemaProps<T, ExtraFields = {}> = Types.Simplify<HasId & ToMutable<T> & ExtraFields>;
+export type EchoTypeSchemaProps<T, ExtraFields = {}> = Types.Simplify<AnyEntity & ToMutable<T> & ExtraFields>;
 
 // TODO(burdon): Rename EchoEntitySchema.
-export interface EchoTypeSchema<Self extends Schema.Schema.Any, ExtraFields = {}>
-  extends TypeMeta,
+export interface EchoTypeSchema<
+  Self extends Schema.Schema.Any,
+  ExtraFields = {},
+  K extends EntityKind = EntityKind,
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+>
+  extends
+    TypeMeta,
     Schema.AnnotableClass<
-      EchoTypeSchema<Self, ExtraFields>,
+      EchoTypeSchema<Self, ExtraFields, K, Fields>,
       EchoTypeSchemaProps<Schema.Schema.Type<Self>, ExtraFields>,
       EchoTypeSchemaProps<Schema.Schema.Encoded<Self>, ExtraFields>,
       Schema.Schema.Context<Self>
     > {
-  // make(
-  //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
-  //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
-  //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
-  //   options?: MakeOptions,
-  // ): Simplify<Schema.TypeLiteral.Type<Fields, []>>;
+  /**
+   * Schema kind key that marks this as an ECHO schema and indicates its kind.
+   * Makes EchoTypeSchema satisfy the Type.AnyObj or Type.Relation.Any type.
+   */
+  readonly [SchemaKindId]: K;
+
+  /**
+   * The fields defined in the original struct schema.
+   * Allows accessing field definitions for introspection.
+   */
+  readonly fields: Fields;
 
   instanceOf(value: unknown): boolean;
 }
 
-// type MakeOptions =
+// type MakeProps =
 //   | boolean
 //   | {
 //       readonly disableValidation?: boolean;
@@ -63,18 +74,24 @@ export interface EchoTypeSchema<Self extends Schema.Schema.Any, ExtraFields = {}
 //   return out;
 // };
 
-// const _getDisableValidationMakeOption = (options: MakeOptions | undefined): boolean =>
+// const _getDisableValidationMakeOption = (options: MakeProps | undefined): boolean =>
 //   Predicate.isBoolean(options) ? options : options?.disableValidation ?? false;
 
 /**
  * @internal
  */
-export const makeEchoTypeSchema = <Self extends Schema.Schema.Any>(
-  // fields: Fields,
+export const makeEchoTypeSchema = <
+  Self extends Schema.Schema.Any,
+  K extends EntityKind = EntityKind,
+  // TODO(wittjosiah): Can this be inferred from the schema?
+  Fields extends Schema.Struct.Fields = Schema.Struct.Fields,
+>(
+  fields: Fields,
   ast: SchemaAST.AST,
   typename: string,
   version: string,
-): EchoTypeSchema<Self> => {
+  kind: K,
+): EchoTypeSchema<Self, {}, K, Fields> => {
   return class EchoObjectSchemaClass extends Schema.make<
     EchoTypeSchemaProps<Schema.Schema.Type<Self>>,
     EchoTypeSchemaProps<Schema.Schema.Encoded<Self>>,
@@ -82,19 +99,21 @@ export const makeEchoTypeSchema = <Self extends Schema.Schema.Any>(
   >(ast) {
     static readonly typename = typename;
     static readonly version = version;
+    static readonly [SchemaKindId] = kind;
+    static readonly fields = fields;
 
     static override annotations(
       annotations: Schema.Annotations.GenericSchema<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>,
-    ): EchoTypeSchema<Self> {
+    ): EchoTypeSchema<Self, {}, K, Fields> {
       const schema = Schema.make<EchoTypeSchemaProps<Schema.Schema.Type<Self>>>(ast).annotations(annotations);
-      return makeEchoTypeSchema<Self>(/* fields, */ schema.ast, typename, version);
+      return makeEchoTypeSchema<Self, K, Fields>(fields, schema.ast, typename, version, kind);
     }
 
     // static make(
     //   props: RequiredKeys<Schema.TypeLiteral.Constructor<Fields, []>> extends never
     //     ? void | Simplify<Schema.TypeLiteral.Constructor<Fields, []>>
     //     : Simplify<Schema.TypeLiteral.Constructor<Fields, []>>,
-    //   options?: MakeOptions,
+    //   options?: MakeProps,
     // ): Simplify<Schema.TypeLiteral.Type<Fields, []>> {
     //   const propsWithDefaults: any = _lazilyMergeDefaults(fields, { ...(props as any) });
     //   return _getDisableValidationMakeOption(options)

package/src/internal/{entities → Entity}/index.ts

@@ -2,8 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './expando';
+export * from './api';
+export * from './entity';
 export * from './model'; // TODO(burdon): Rename.
 export * from './object';
 export * from './relation';
 export * from './util';
+export * from './version';