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

package/src/Entity.ts

@@ -2,46 +2,30 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
 import type { ForeignKey } from '@dxos/echo-protocol';
-import type { DXN, ObjectId } from '@dxos/keys';
-
-import {
-  type ChangeCallback,
-  EntityKind,
-  EntityKindSchema,
-  KindId,
-  type Mutable,
-  type ObjectJSON,
-  type ObjectMeta,
-  type ReadonlyMeta,
-  SnapshotKindId,
-  addTag as addTag$,
-  change as change$,
-  getDXN as getDXN$,
-  getDatabase as getDatabase$,
-  getDescription as getDescription$,
-  getEntityKind,
-  getKeys as getKeys$,
-  getLabel as getLabel$,
-  getMetaChecked as getMeta$,
-  getTypeDXN as getTypeDXN$,
-  getTypename as getTypename$,
-  isDeleted as isDeleted$,
-  removeTag as removeTag$,
-  subscribe as subscribe$,
-  objectToJSON as toJSON$,
-} from './internal';
+import type { ObjectId, URI } from '@dxos/keys';
+
+import * as internal from './internal';
+import type * as Relation from './Relation';
+import * as Type from './Type';
 
 // Re-export KindId and SnapshotKindId from internal.
-export { KindId, SnapshotKindId };
+export const KindId = internal.KindId;
+export type KindId = typeof internal.KindId;
+export const SnapshotKindId = internal.SnapshotKindId;
+export type SnapshotKindId = typeof internal.SnapshotKindId;
 
 // NOTE: Relation does not extend Obj so that, for example, we can prevent Relations from being used as source and target objects.
 //  However, we generally refer to Obj and Relation instances as "objects",
 //  and many API methods accept both Obj.Unknown and Relation.Unknown (i.e., Entity.Unknown) instances.
 
-export const Kind = EntityKind;
-export type Kind = EntityKind;
-export const KindSchema = EntityKindSchema;
+export const Kind = internal.EntityKind;
+export type Kind = internal.EntityKind;
+export const KindSchema = internal.EntityKindSchema;
 
 /**
  * Assigns a kind to an Object or Relation instance.
@@ -70,6 +54,27 @@ export type Entity<Props> = OfKind<Kind> & Props;
  */
 export interface Unknown extends OfKind<Kind> {}
 
+/**
+ * Effect Schema for any ECHO entity (object or relation).
+ *
+ * Kind-agnostic counterpart to `Obj.Unknown` / `Relation.Unknown` — validates
+ * the structural shape (id + properties) without constraining `[KindId]`. Used
+ * in operation input schemas that accept any entity flavour (e.g.
+ * `Schema.Array(Entity.Unknown)`).
+ *
+ * The cast bridges the runtime structural schema to the branded `Unknown` type:
+ * `[KindId]` is a symbol brand that can't be expressed in a runtime `Struct`,
+ * so the entity guarantee is carried at the type level only (same approach as
+ * `Obj.Unknown` / `Relation.Unknown`). Unlike those, this is kind-agnostic so it
+ * isn't an `UnknownTypeSchema<_, K>` (there's no single `K`) and carries no
+ * `TypeAnnotation`.
+ */
+export const Unknown: Schema.Schema<Unknown> = Schema.Struct({
+  id: Schema.String,
+}).pipe(
+  Schema.extend(Schema.Record({ key: Schema.String, value: Schema.Unknown })),
+) as unknown as Schema.Schema<Unknown>;
+
 /**
  * Snapshot of an Obj or Relation.
  * Branded with SnapshotKindId instead of KindId.
@@ -89,7 +94,68 @@ export interface Any extends OfKind<Kind> {
   [key: string]: unknown;
 }
 
-export const getKind = getEntityKind;
+/**
+ * Returns all properties of an object or relation except for the id and kind.
+ */
+export type Properties<T> = Omit<T, 'id' | KindId | Relation.Source | Relation.Target>;
+
+/**
+ * Check if a value is an ECHO entity (object or relation).
+ * Returns `false` for snapshots.
+ */
+export const isEntity = (value: unknown): value is Unknown => {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  return (value as any)[KindId] !== undefined;
+};
+
+/**
+ * Test if a value is an instance of a given object or relation type.
+ *
+ * Kind-agnostic counterpart to `Obj.instanceOf` / `Relation.instanceOf` —
+ * use this when the caller's input type is `Type.AnyObj | Type.AnyRelation`.
+ *
+ * @example
+ * ```ts
+ * // Caller doesn't know whether `type` is object- or relation-kind.
+ * const matches = <T extends Type.AnyObj | Type.AnyRelation>(type: T, value: unknown) =>
+ *   Entity.instanceOf(type, value);
+ * ```
+ */
+export const instanceOf: {
+  <S extends Type.AnyEntity>(schema: S): (value: unknown) => value is Type.InstanceType<S>;
+  <S extends Type.AnyEntity>(schema: S, value: unknown): value is Type.InstanceType<S>;
+} = ((...args: [schema: Type.AnyEntity, value?: unknown]) => {
+  if (args.length === 1) {
+    return (entity: unknown) => internal.isInstanceOf(args[0], entity);
+  }
+  return internal.isInstanceOf(args[0], args[1]);
+}) as any;
+
+/**
+ * Check if a value is an ECHO entity snapshot.
+ * Returns `false` for entities.
+ */
+export const isSnapshot = (value: unknown): value is Snapshot => {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  return (value as any)[SnapshotKindId] !== undefined;
+};
+
+// TODO(dmaretskyi): Type introspection -- move to kind.
+export const getKind = internal.getEntityKind;
+
+/**
+ * Property that accesses metadata for an entity.
+ */
+export const Meta: unique symbol = internal.MetaId as any;
+
+/**
+ * Property that accesses metadata for an entity.
+ */
+export type Meta = typeof Meta;
 
 //
 // Entity-level functions that work on any entity (object or relation).
@@ -100,27 +166,66 @@ export const getKind = getEntityKind;
 /**
  * JSON representation of an entity.
  */
-export type JSON = ObjectJSON;
+export type JSON = internal.ObjectJSON;
+
+/**
+ * Whether the entity is a type-kind entity (a `Type.Type` produced by
+ * `Type.makeObject` / `Type.makeRelation`, or a persisted schema). Type entities
+ * carry their identity (typename/version) on themselves rather than referencing a
+ * separate type, so the accessors below route them through the `Type.*` module.
+ */
+const isTypeEntity = (entity: unknown): boolean => internal.getEntityKindBrand(entity) === internal.EntityKind.Type;
 
 /**
- * Get the DXN of an entity (object or relation).
+ * Any value the read accessors operate on: a reactive entity or a snapshot.
+ * Type entities (`Type.AnyEntity`) are also accepted — they're first-class
+ * entities, and `Unknown`'s kind-agnostic brand already subsumes them.
  */
-export const getDXN = (entity: Unknown | Snapshot): DXN => getDXN$(entity);
+export type AnyInput = Unknown | Snapshot;
 
 /**
- * Get the DXN of an entity's type.
+ * Get the canonical URI of an entity (object, relation, or type). Returns `URI.URI` —
+ * an `EchoURI` for object/relation instances and persisted types, or a typename
+ * `DXN` for static type entities; narrow with `EchoURI.parse(uri)` or
+ * `DXN.tryMake(uri)` at the point of use.
  */
-export const getTypeDXN = getTypeDXN$;
+export const getURI = (entity: AnyInput): URI.URI =>
+  isTypeEntity(entity) ? Type.getURI(entity as Type.AnyEntity) : internal.getUri(entity as Unknown);
 
 /**
- * Get the typename of an entity's type.
+ * Get the DXN of an entity's type. For object/relation instances this is the URI
+ * of the type they were created from; for a type entity it is the URI of the
+ * meta-type ({@link Type.Type}, `dxn:org.dxos.type.schema:0.1.0`).
  */
-export const getTypename = (entity: Unknown | Snapshot): string | undefined => getTypename$(entity);
+export const getTypeURI = (entity: AnyInput): URI.URI | undefined =>
+  isTypeEntity(entity) ? Type.getURI(Type.Type) : internal.getTypeURI(entity as Unknown);
+
+/**
+ * Get the type entity (`Type.AnyEntity`) the instance was created from.
+ *
+ * Returns `undefined` when the entity's type isn't registered in this runtime
+ * (e.g. a freshly deserialized snapshot whose type entity hasn't been wired
+ * up yet, or an entity loaded from storage before its schema is known). To
+ * get the Effect Schema from the returned entity, use `Type.getSchema(...)`.
+ *
+ * For a type entity, returns the meta-type {@link Type.Type} (a type entity's
+ * type is "Type").
+ */
+export const getType = (entity: AnyInput): Type.AnyEntity | undefined =>
+  isTypeEntity(entity) ? Type.Type : (internal.getType(entity) as Type.AnyEntity | undefined);
+
+/**
+ * Get the typename of an entity's type. For object/relation instances this is the
+ * typename of the type they were created from; for a type entity it is the type's
+ * own typename (e.g. `com.example.type.person`).
+ */
+export const getTypename = (entity: AnyInput): string | undefined =>
+  isTypeEntity(entity) ? Type.getTypename(entity as Type.AnyEntity) : internal.getTypename(entity as Unknown);
 
 /**
  * Get the database an entity belongs to.
  */
-export const getDatabase = (entity: Unknown | Snapshot): any | undefined => getDatabase$(entity);
+export const getDatabase = (entity: Unknown | Snapshot): any | undefined => internal.getDatabase(entity);
 
 /**
  * Get the metadata for an entity.
@@ -128,43 +233,53 @@ export const getDatabase = (entity: Unknown | Snapshot): any | undefined => getD
  * Returns read-only meta when passed a regular entity or snapshot.
  */
 // TODO(wittjosiah): When passed a Snapshot, should return a snapshot of meta, not the live meta proxy.
-export function getMeta(entity: Mutable<Unknown>): ObjectMeta;
-export function getMeta(entity: Unknown | Snapshot): ReadonlyMeta;
-export function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): ObjectMeta | ReadonlyMeta {
-  return getMeta$(entity);
+export function getMeta(entity: Mutable<Unknown>): internal.ObjectMeta;
+export function getMeta(entity: Unknown | Snapshot): internal.ReadonlyMeta;
+export function getMeta(entity: Unknown | Snapshot | Mutable<Unknown>): internal.ObjectMeta | internal.ReadonlyMeta {
+  return internal.getMetaChecked(entity);
 }
 
 /**
  * Get foreign keys for an entity from the specified source.
  */
-export const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => getKeys$(entity, source);
+export const getKeys = (entity: Unknown | Snapshot, source: string): ForeignKey[] => internal.getKeys(entity, source);
 
 /**
  * Check if an entity is deleted.
  */
-export const isDeleted = (entity: Unknown | Snapshot): boolean => isDeleted$(entity);
+export const isDeleted = (entity: Unknown | Snapshot): boolean => internal.isDeleted(entity);
 
 /**
  * Get the label of an entity.
+ *
+ * @param options.fallback `'typename'` returns the entity's typename when no
+ *   label is set (e.g. `org.dxos.type.table`).
+ */
+export const getLabel = (entity: Unknown | Snapshot, options?: internal.GetLabelOptions): string | undefined =>
+  internal.getLabel(entity, options);
+
+/**
+ * Set the label of an entity.
+ * Must be called within an `Entity.update` / `Obj.update` / `Relation.update` callback.
  */
-export const getLabel = (entity: Unknown | Snapshot): string | undefined => getLabel$(entity);
+export const setLabel = (entity: Mutable<Unknown>, label: string): void => internal.setLabel(entity, label);
 
 /**
  * Get the description of an entity.
  */
-export const getDescription = (entity: Unknown | Snapshot): string | undefined => getDescription$(entity);
+export const getDescription = (entity: Unknown | Snapshot): string | undefined => internal.getDescription(entity);
 
 /**
  * Convert an entity to its JSON representation.
  */
-export const toJSON = (entity: Unknown | Snapshot): JSON => toJSON$(entity);
+export const toJSON = (entity: Unknown | Snapshot): JSON => internal.objectToJSON(entity);
 
 /**
  * Subscribe to changes on an entity (object or relation).
  * @returns Unsubscribe function.
  */
 export const subscribe = (entity: Unknown, callback: () => void): (() => void) => {
-  return subscribe$(entity, callback);
+  return internal.subscribe(entity, callback);
 };
 
 //
@@ -172,15 +287,15 @@ export const subscribe = (entity: Unknown, callback: () => void): (() => void) =
 //
 
 /**
- * Used to provide a mutable view of an entity within `Entity.change`.
+ * Used to provide a mutable view of an entity within `Entity.update`.
  */
-export type { Mutable };
+export type Mutable<T> = internal.Mutable<T>;
 
 /**
  * Perform mutations on an entity (object or relation) within a change context.
  *
  * Entities are read-only by default. Mutations are batched and notifications fire
- * when the callback completes. Direct mutations outside of `Entity.change` will throw
+ * when the callback completes. Direct mutations outside of `Entity.update` will throw
  * at runtime.
  *
  * @param entity - The echo entity (object or relation) to mutate.
@@ -188,30 +303,30 @@ export type { Mutable };
  *
  * @example
  * ```typescript
- * // Mutate within Entity.change
- * Entity.change(entity, (e) => {
- *   e.name = 'Updated';
- *   e.count = 42;
+ * // Mutate within Entity.update
+ * Entity.update(entity, (obj) => {
+ *   obj.name = 'Updated';
+ *   obj.count = 42;
  * });
  *
  * // Direct mutation throws
- * entity.name = 'Bob'; // Error: Cannot modify outside Entity.change()
+ * entity.name = 'Bob'; // Error: Cannot modify outside Entity.update()
  * ```
  *
- * Note: For type-specific operations, prefer `Obj.change` or `Relation.change`.
+ * Note: For type-specific operations, prefer `Obj.update` or `Relation.update`.
  */
-export const change = <T extends Unknown>(entity: T, callback: ChangeCallback<T>): void => {
-  change$(entity, callback);
+export const update = <T extends Unknown>(entity: T, callback: internal.ChangeCallback<T>): void => {
+  internal.change(entity, callback);
 };
 
 /**
  * Add a tag to an entity.
- * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.
+ * Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.
  */
-export const addTag = (entity: Mutable<Unknown>, tag: string): void => addTag$(entity, tag);
+export const addTag = (entity: Mutable<Unknown>, tag: string): void => internal.addTag(entity, tag);
 
 /**
  * Remove a tag from an entity.
- * Must be called within an `Entity.change`, `Obj.change`, or `Relation.change` callback.
+ * Must be called within an `Entity.update`, `Obj.update`, or `Relation.update` callback.
  */
-export const removeTag = (entity: Mutable<Unknown>, tag: string): void => removeTag$(entity, tag);
+export const removeTag = (entity: Mutable<Unknown>, tag: string): void => internal.removeTag(entity, tag);

package/src/Err.ts

@@ -2,8 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
+// @import-as-namespace
+
 import { BaseError, type BaseErrorOptions } from '@dxos/errors';
-import { type DXN } from '@dxos/keys';
+import { type URI } from '@dxos/keys';
 
 export class SchemaNotFoundError extends BaseError.extend('SchemaNotFoundError', 'Schema not found') {
   constructor(schema: string, options?: BaseErrorOptions) {
@@ -12,7 +14,27 @@ export class SchemaNotFoundError extends BaseError.extend('SchemaNotFoundError',
 }
 
 export class ObjectNotFoundError extends BaseError.extend('ObjectNotFoundError', 'Object not found') {
-  constructor(dxn: DXN, options?: BaseErrorOptions) {
-    super({ context: { dxn }, ...options });
+  constructor(uri: URI.URI, options?: BaseErrorOptions) {
+    super({ context: { uri }, ...options });
+  }
+}
+
+/**
+ * Reason why getting a reactive object from a snapshot failed.
+ * - `no-database`: The snapshot is not associated with a database.
+ * - `object-not-found`: The object was removed or does not exist in the database.
+ */
+export type GetReactiveErrorReason = 'no-database' | 'object-not-found';
+
+/**
+ * Error thrown when a reactive object cannot be resolved from a snapshot.
+ * Extends `BaseError` with a `reason` and optional `snapshotId` in its context.
+ */
+export class GetReactiveError extends BaseError.extend(
+  'GetReactiveError',
+  'Failed to get reactive object from snapshot',
+) {
+  constructor(options: { reason: GetReactiveErrorReason; snapshotId?: string } & BaseErrorOptions) {
+    super({ context: { reason: options.reason, snapshotId: options.snapshotId }, ...options });
   }
 }

package/src/Extension.test.ts

@@ -0,0 +1,235 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Option from 'effect/Option';
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import * as Extension from './Extension';
+
+describe('Extension', () => {
+  describe('make', () => {
+    test('creates an extension with a string schema', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+
+      expect(ColorExtension.key).toBe('color');
+      expect(ColorExtension.valueSchema).toBe(Schema.String);
+      expect(ColorExtension[Extension.TypeId]).toBeDefined();
+    });
+
+    test('creates an extension with a number schema', ({ expect }) => {
+      const PriorityExtension = Extension.make('priority', Schema.Number);
+
+      expect(PriorityExtension.key).toBe('priority');
+      expect(PriorityExtension.valueSchema).toBe(Schema.Number);
+    });
+
+    test('creates an extension with a complex schema', ({ expect }) => {
+      const MetadataSchema = Schema.Struct({
+        author: Schema.String,
+        version: Schema.Number,
+        tags: Schema.Array(Schema.String),
+      });
+      const MetadataExtension = Extension.make('metadata', MetadataSchema);
+
+      expect(MetadataExtension.key).toBe('metadata');
+      expect(MetadataExtension.valueSchema).toBe(MetadataSchema);
+    });
+  });
+
+  describe('get and set', () => {
+    test('set and get a string value', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      Extension.set(values, ColorExtension, 'red');
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('red');
+    });
+
+    test('set and get a number value', ({ expect }) => {
+      const PriorityExtension = Extension.make('priority', Schema.Number);
+      const values: Extension.Values = {};
+
+      Extension.set(values, PriorityExtension, 42);
+      const result = Extension.get(values, PriorityExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe(42);
+    });
+
+    test('set and get a boolean value', ({ expect }) => {
+      const EnabledExtension = Extension.make('enabled', Schema.Boolean);
+      const values: Extension.Values = {};
+
+      Extension.set(values, EnabledExtension, true);
+      const result = Extension.get(values, EnabledExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe(true);
+    });
+
+    test('set and get a complex object value', ({ expect }) => {
+      const ConfigSchema = Schema.Struct({
+        theme: Schema.String,
+        fontSize: Schema.Number,
+        darkMode: Schema.Boolean,
+      });
+      const ConfigExtension = Extension.make('config', ConfigSchema);
+      const values: Extension.Values = {};
+
+      const config = { theme: 'modern', fontSize: 14, darkMode: true };
+      Extension.set(values, ConfigExtension, config);
+      const result = Extension.get(values, ConfigExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toEqual(config);
+    });
+
+    test('set and get an array value', ({ expect }) => {
+      const TagsExtension = Extension.make('tags', Schema.Array(Schema.String));
+      const values: Extension.Values = {};
+
+      const tags = ['important', 'urgent', 'review'];
+      Extension.set(values, TagsExtension, tags);
+      const result = Extension.get(values, TagsExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toEqual(tags);
+    });
+
+    test('get returns None for missing extension', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isNone(result)).toBe(true);
+    });
+
+    test('overwriting an extension value', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      Extension.set(values, ColorExtension, 'red');
+      Extension.set(values, ColorExtension, 'blue');
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('blue');
+    });
+
+    test('multiple extensions on the same values object', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const PriorityExtension = Extension.make('priority', Schema.Number);
+      const EnabledExtension = Extension.make('enabled', Schema.Boolean);
+      const values: Extension.Values = {};
+
+      Extension.set(values, ColorExtension, 'green');
+      Extension.set(values, PriorityExtension, 5);
+      Extension.set(values, EnabledExtension, false);
+
+      expect(Option.getOrThrow(Extension.get(values, ColorExtension))).toBe('green');
+      expect(Option.getOrThrow(Extension.get(values, PriorityExtension))).toBe(5);
+      expect(Option.getOrThrow(Extension.get(values, EnabledExtension))).toBe(false);
+    });
+  });
+
+  describe('curried forms', () => {
+    test('get curried form', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+      Extension.set(values, ColorExtension, 'purple');
+
+      const getColor = Extension.get(ColorExtension);
+      const result = getColor(values);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('purple');
+    });
+
+    test('set curried form', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      const setOrange = Extension.set(ColorExtension, 'orange');
+      setOrange(values);
+      const result = Extension.get(values, ColorExtension);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('orange');
+    });
+
+    test('curried forms work in pipelines', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+
+      Extension.set(ColorExtension, 'cyan')(values);
+      const result = Extension.get(ColorExtension)(values);
+
+      expect(Option.isSome(result)).toBe(true);
+      expect(Option.getOrThrow(result)).toBe('cyan');
+    });
+  });
+
+  describe('Key', () => {
+    test('Key.make creates a branded key', ({ expect }) => {
+      const key = Extension.Key.make('my-extension');
+
+      expect(key).toBe('my-extension');
+      expect(typeof key).toBe('string');
+    });
+  });
+
+  describe('Values schema', () => {
+    test('Values can be used as a schema', ({ expect }) => {
+      const PersonWithExtensions = Schema.Struct({
+        name: Schema.String,
+        extensions: Extension.Values,
+      });
+
+      const person = Schema.decodeUnknownSync(PersonWithExtensions)({
+        name: 'Alice',
+        extensions: {},
+      });
+
+      expect(person.name).toBe('Alice');
+      expect(person.extensions).toEqual({});
+    });
+
+    test('Values schema accepts extension data', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+      const values: Extension.Values = {};
+      Extension.set(values, ColorExtension, 'red');
+
+      const PersonWithExtensions = Schema.Struct({
+        name: Schema.String,
+        extensions: Extension.Values,
+      });
+
+      const person = Schema.decodeUnknownSync(PersonWithExtensions)({
+        name: 'Bob',
+        extensions: values,
+      });
+
+      expect(person.name).toBe('Bob');
+      const color = Extension.get(person.extensions, ColorExtension);
+      expect(Option.getOrThrow(color)).toBe('red');
+    });
+  });
+
+  describe('TypeId', () => {
+    test('TypeId is a unique symbol-like string', ({ expect }) => {
+      expect(Extension.TypeId).toBe('~@dxos/echo/Extension');
+    });
+
+    test('extensions have TypeId property', ({ expect }) => {
+      const ColorExtension = Extension.make('color', Schema.String);
+
+      expect(Extension.TypeId in ColorExtension).toBe(true);
+    });
+  });
+});