@dxos/echo 0.8.4-staging.ac66bdf99f → 0.9.0

package/src/Filter.ts

@@ -11,11 +11,13 @@ import type * as Types from 'effect/Types';
 
 import { type ForeignKey, type QueryAST } from '@dxos/echo-protocol';
 import { assertArgument } from '@dxos/invariant';
-import { DXN, ObjectId } from '@dxos/keys';
+import { EID, EntityId, type URI } from '@dxos/keys';
 
 import * as internal from './internal';
 import type * as Obj from './Obj';
 import * as Ref from './Ref';
+// eslint-disable-next-line @dxos/rules/import-as-namespace
+import type * as Type$ from './Type';
 
 export interface Filter<T> {
   // TODO(dmaretskyi): See new effect-schema approach to variance.
@@ -77,11 +79,11 @@ export const nothing = (): FilterClass => {
 };
 
 /*
- * Filter by ObjectId.
+ * Filter by EntityId.
  */
-export const id = (...ids: ObjectId[]): Any => {
+export const id = (...ids: EntityId[]): Any => {
   assertArgument(
-    ids.every((id) => ObjectId.isValid(id)),
+    ids.every((id) => EntityId.isValid(id)),
     'ids',
     'ids must be valid',
   );
@@ -100,61 +102,89 @@ export const id = (...ids: ObjectId[]): Any => {
 
 /**
  * Filter by type.
+ *
+ * Accepts a `Type.Type` entity (the value produced by `Type.makeObject` /
+ * `Type.makeRelation`), a `Schema.Union` of such entities (for filtering across a
+ * union of ECHO types), or a fully-qualified type URI — an `echo:` EID (stored schema)
+ * or a `dxn:` DXN (static schema). To filter by a bare typename, wrap it: `DXN.make(typename)`.
  */
-export const type = <S extends Schema.Schema.All>(
-  schema: S | string,
-  props?: Props<Schema.Schema.Type<S>>,
-): Filter<Schema.Schema.Type<S>> => {
-  if (Schema.isSchema(schema) && SchemaAST.isUnion(schema.ast)) {
-    const typenames = schema.ast.types.map((type) => internal.getTypeDXNFromSpecifier(Schema.make(type)));
+export const type: {
+  <T extends Type$.AnyEntity>(type: T, props?: Props<Type$.InstanceType<T>>): Filter<Type$.InstanceType<T>>;
+  // Schema-side overload restricted to the well-known unknown schemas and to
+  // `Schema.Union(...)` of `Type.Type` entities (for filtering across a union
+  // of ECHO types). Other raw schemas are rejected.
+  <S extends internal.UnknownTypeSchema<any, any>>(
+    schema: S,
+    props?: Props<Schema.Schema.Type<S>>,
+  ): Filter<Schema.Schema.Type<S>>;
+  <S extends Schema.Union<readonly Schema.Schema.AnyNoContext[]>>(
+    union: S,
+    props?: Props<Schema.Schema.Type<S>>,
+  ): Filter<Schema.Schema.Type<S>>;
+  (uri: URI.URI, props?: Props<unknown>): Filter<any>;
+  // Passthrough overload for callers that hold a `Type.AnyEntity | URI.URI` union
+  // (e.g. Query.type / Query.sourceOf / Query.targetOf impls). Listed last so the
+  // typed overloads above still win for monomorphic inputs.
+  (input: Type$.AnyEntity | URI.URI, props?: Props<unknown>): Filter<unknown>;
+} = (input: Type$.AnyEntity | Schema.Schema.AnyNoContext | URI.URI, props?: Props<unknown>): any => {
+  if (Schema.isSchema(input) && SchemaAST.isUnion(input.ast)) {
+    const typenames = input.ast.types.map((t) => internal.getTypeURIFromSpecifier(Schema.make(t)));
     return new FilterClass({
       type: 'or',
       filters: typenames.map((typename) => ({
         type: 'object',
-        typename: typename.toString(),
+        typename,
         props: {},
       })),
     });
   }
 
-  const dxn = internal.getTypeDXNFromSpecifier(schema);
+  const uri = internal.getTypeURIFromSpecifier(input);
   return new FilterClass({
     type: 'object',
-    typename: dxn.toString(),
+    typename: uri,
     ...propsFilterToAst(props ?? {}),
   });
 };
 
 /**
- * Filter by non-qualified typename.
+ * Filter by tag.
  */
-export const typename = (typename: string): Any => {
-  assertArgument(!typename.startsWith('dxn:'), 'typename', 'Typename must no be qualified');
+export const tag = (tag: string): Any => {
   return new FilterClass({
-    type: 'object',
-    typename: DXN.fromTypename(typename).toString(),
-    props: {},
+    type: 'tag',
+    tag,
   });
 };
 
 /**
- * Filter by fully qualified type DXN.
+ * Options for {@link key} filter.
  */
-export const typeDXN = (dxn: DXN): Any => {
-  return new FilterClass({
-    type: 'object',
-    typename: dxn.toString(),
-    props: {},
-  });
+export type KeyFilterOptions = {
+  /**
+   * Optional semver range expression (e.g. `^1.2.3`, `~2.0.0`, `>=1.0.0 <2.0.0`).
+   * Matches the object's meta `version` field against the range.
+   * If omitted, matches any version (including objects with no version).
+   */
+  version?: string;
 };
 
 /**
- * Filter by tag.
+ * Filter by registry key stored in object meta.
+ *
+ * @example
+ * ```ts
+ * Filter.key('org.example.type.foo');
+ * Filter.key('org.example.type.foo', { version: '^1.2.3' });
+ * ```
  */
-export const tag = (tag: string): Any => {
+export const key = (key: string, options?: KeyFilterOptions): Any => {
   return new FilterClass({
-    type: 'tag',
-    tag,
+    type: 'object',
+    typename: null,
+    props: {},
+    metaKey: key,
+    metaVersion: options?.version,
   });
 };
 
@@ -192,14 +222,14 @@ export const text = (
 /**
  * Filter by foreign keys.
  */
-export const foreignKeys = <S extends Schema.Schema.All>(
-  schema: S | string,
+export const foreignKeys = <S extends Type$.AnyEntity | URI.URI>(
+  schema: S,
   keys: ForeignKey[],
-): Filter<Schema.Schema.Type<S>> => {
-  const dxn = internal.getTypeDXNFromSpecifier(schema);
+): Filter<S extends Type$.AnyEntity ? Type$.InstanceType<S> : unknown> => {
+  const uri = internal.getTypeURIFromSpecifier(schema);
   return new FilterClass({
     type: 'object',
-    typename: dxn.toString(),
+    typename: uri,
     props: {},
     foreignKeys: keys,
   });
@@ -347,7 +377,7 @@ export type ChildOfOptions = {
 /**
  * Filter objects that are children of the specified parent(s).
  * Accepts ECHO objects, Refs, or arrays of either.
- * Refs are resolved to DXNs without loading; objects use {@link Obj.getDXN}.
+ * Refs are resolved to DXNs without loading; objects use {@link Obj.getURI}.
  * With transitive=true (default), also matches grandchildren and beyond.
  */
 export const childOf = (
@@ -357,9 +387,9 @@ export const childOf = (
   const items = Array.isArray(parents) ? parents : [parents];
   const dxns = items.map((item) => {
     if (Ref.isRef(item)) {
-      return item.dxn.toString();
+      return EID.parse(item.uri);
     }
-    return internal.getDXN(item).toString();
+    return EID.parse(internal.getUri(item));
   });
   return new FilterClass({
     type: 'child-of',
@@ -401,7 +431,7 @@ export const or = <Filters extends readonly Any[]>(...filters: Filters): Filter<
 // TODO(dmaretskyi): Add `Filter.match` to support pattern matching on string props.
 
 const propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, 'id' | 'props'> => {
-  let idFilter: readonly ObjectId[] | undefined;
+  let idFilter: readonly EntityId[] | undefined;
   if ('id' in predicates) {
     assertArgument(
       typeof predicates.id === 'string' || Array.isArray(predicates.id),
@@ -409,7 +439,7 @@ const propsFilterToAst = (predicates: Props<any>): Pick<QueryAST.FilterObject, '
       'invalid id filter',
     );
     idFilter = typeof predicates.id === 'string' ? [predicates.id] : predicates.id;
-    Schema.Array(ObjectId).pipe(Schema.validateSync)(idFilter);
+    Schema.Array(EntityId).pipe(Schema.validateSync)(idFilter);
   }
 
   return {

package/src/Format.ts

@@ -2,8 +2,4 @@
 // Copyright 2025 DXOS.org
 //
 
-import type * as internal from './internal';
-
 export * from './internal/Format';
-
-export type Format = internal.TypeFormat;

package/src/Hypergraph.ts

@@ -2,14 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type DXN } from '@dxos/keys';
+import { type URI } from '@dxos/keys';
 
 import type * as Database from './Database';
 import type * as Entity from './Entity';
 import type * as internal from './internal';
 import type * as Key from './Key';
 import type * as Ref from './Ref';
-import type * as SchemaRegistry from './SchemaRegistry';
+import type * as Registry from './Registry';
 
 /**
  * Resolution context.
@@ -22,10 +22,10 @@ export interface RefResolutionContext {
   space?: Key.SpaceId;
 
   /**
-   * Queue that the resolution is happening from.
-   * This queue will be searched first, and then the space it belongs to.
+   * Feed that the resolution is happening from.
+   * This feed will be searched first, and then the space it belongs to.
    */
-  queue?: DXN;
+  feed?: URI.URI;
 }
 
 export interface RefResolverOptions {
@@ -46,7 +46,12 @@ export interface RefResolverOptions {
  * Manages cross-space database interactions.
  */
 export interface Hypergraph extends Database.Queryable {
-  get schemaRegistry(): SchemaRegistry.SchemaRegistry;
+  /**
+   * In-process registry of keyed objects and static schema types.
+   * Populated at startup via `registry.add(objects)` / `registry.add(schemas)`.
+   * Queries that include no explicit from() clause will fan out to this registry automatically.
+   */
+  get registry(): Registry.Registry;
 
   /**
    * Query objects.
@@ -57,11 +62,11 @@ export interface Hypergraph extends Database.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.Ref<T>;
+  makeRef<T extends Entity.Unknown = Entity.Unknown>(uri: URI.URI): Ref.Ref<T>;
 
   /**
    * @param hostDb Host database for reference resolution.

package/src/Json.test.ts

@@ -0,0 +1,175 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { DXN, EID, EntityId } from '@dxos/keys';
+import { safeStringify } from '@dxos/util';
+
+import * as Database from './Database';
+import * as Json from './Json';
+
+/** Mint a random ECHO object id usable as both a stub-db key and a DXN payload. */
+const newId = (): string => EntityId.random();
+
+/** Build a fake encoded ref for a local-space object id. */
+const encodeRef = (id: string): { '/': string } => ({ '/': EID.make({ entityId: id }) });
+
+/** Minimal stub: `createRefReplacer` only touches `db.getObjectById`. */
+const makeStubDb = (objects: Record<string, unknown>): Database.Database => {
+  return {
+    getObjectById: (id: string) => objects[id],
+  } as unknown as Database.Database;
+};
+
+/**
+ * Run a value through the replacer's public contract — `JSON.stringify(value, replacer)` —
+ * then re-parse the result so tests can assert on plain JS shapes. This mirrors the way
+ * the JSON highlighter invokes the replacer in production.
+ */
+const stringifyWith = (replacer: Json.JsonReplacer, value: unknown): unknown =>
+  JSON.parse(JSON.stringify(value, replacer));
+
+describe('createRefReplacer', () => {
+  test('passes plain values through unchanged', () => {
+    const replacer = Json.createRefReplacer({ db: makeStubDb({}) });
+    const subject = { a: 1, b: 'two', c: [3, { d: 4 }] };
+    expect(stringifyWith(replacer, subject)).toEqual(subject);
+  });
+
+  test('inlines refs at default depth (1)', () => {
+    const id = newId();
+    const target = { name: 'inlined' };
+    const replacer = Json.createRefReplacer({ db: makeStubDb({ [id]: target }) });
+    const subject = { ref: encodeRef(id) };
+    expect(stringifyWith(replacer, subject)).toEqual({ ref: target });
+  });
+
+  test('does not follow refs when depth is 0', () => {
+    const id = newId();
+    const target = { name: 'inlined' };
+    const ref = encodeRef(id);
+    const replacer = Json.createRefReplacer({ db: makeStubDb({ [id]: target }), depth: 0 });
+    expect(stringifyWith(replacer, { ref })).toEqual({ ref });
+  });
+
+  test('inlines refs across multiple levels up to depth', () => {
+    const innerId = newId();
+    const middleId = newId();
+    const inner = { name: 'inner' };
+    const middle = { ref: encodeRef(innerId) };
+    const outer = { ref: encodeRef(middleId) };
+    const db = makeStubDb({ [innerId]: inner, [middleId]: middle });
+
+    expect(stringifyWith(Json.createRefReplacer({ db, depth: 1 }), outer)).toEqual({
+      ref: { ref: encodeRef(innerId) },
+    });
+
+    expect(stringifyWith(Json.createRefReplacer({ db, depth: 2 }), outer)).toEqual({
+      ref: { ref: inner },
+    });
+  });
+
+  test('leaves refs encoded when the target is missing in the db', () => {
+    const ref = encodeRef(newId());
+    const replacer = Json.createRefReplacer({ db: makeStubDb({}) });
+    expect(stringifyWith(replacer, { ref })).toEqual({ ref });
+  });
+
+  test('leaves non-DXN single-key { "/": string } objects untouched', () => {
+    // Same `{ '/': string }` shape is used by other IPLD-style refs (e.g. CIDs); those should
+    // not crash the replacer and should pass through verbatim.
+    const cidLike = { '/': 'bafybeibwzifw7izxykxz' };
+    const replacer = Json.createRefReplacer({ db: makeStubDb({}) });
+    expect(stringifyWith(replacer, { ref: cidLike })).toEqual({ ref: cidLike });
+  });
+
+  test('leaves malformed dxn strings untouched', () => {
+    const malformed = { '/': 'dxn:not-a-real-dxn' };
+    const replacer = Json.createRefReplacer({ db: makeStubDb({}) });
+    expect(stringifyWith(replacer, { ref: malformed })).toEqual({ ref: malformed });
+  });
+
+  test('leaves non-echo dxns untouched (e.g. type DXN)', () => {
+    // Type DXNs share the `dxn:` prefix but `asEchoDXN()` returns undefined.
+    const typeRef = { '/': DXN.make('com.example.Thing') };
+    const replacer = Json.createRefReplacer({ db: makeStubDb({}) });
+    expect(stringifyWith(replacer, { ref: typeRef })).toEqual({ ref: typeRef });
+  });
+
+  test('inlines refs inside arrays', () => {
+    const idA = newId();
+    const idB = newId();
+    const a = { name: 'a' };
+    const b = { name: 'b' };
+    const replacer = Json.createRefReplacer({ db: makeStubDb({ [idA]: a, [idB]: b }) });
+    expect(stringifyWith(replacer, { items: [encodeRef(idA), encodeRef(idB), { plain: true }] })).toEqual({
+      items: [a, b, { plain: true }],
+    });
+  });
+
+  test('walks nested objects recursively', () => {
+    const innerId = newId();
+    const inner = { name: 'inner' };
+    const replacer = Json.createRefReplacer({ db: makeStubDb({ [innerId]: inner }) });
+    const subject = { outer: { mid: { ref: encodeRef(innerId) } } };
+    expect(stringifyWith(replacer, subject)).toEqual({ outer: { mid: { ref: inner } } });
+  });
+
+  test('a single replacer invocation does not recurse on its own', () => {
+    // The replacer is per-call; JSON.stringify drives the tree walk. Calling the replacer
+    // directly on a cyclic input must therefore return without touching the cycle.
+    const replacer = Json.createRefReplacer({ db: makeStubDb({}) });
+    const node: any = { name: 'self' };
+    node.self = node;
+
+    expect(() => replacer('', node)).not.toThrow();
+    expect(replacer('', node)).toBe(node);
+  });
+
+  test('invokes `toJSON` on resolved targets so refs in the target are re-walked', () => {
+    // Simulates the ECHO-object branch: `db.getObjectById` returns a live proxy, the replacer
+    // calls `.toJSON()` to get the encoded form, then continues walking that form. A ref nested
+    // inside the target should be inlined when there's depth budget remaining.
+    const outerId = newId();
+    const innerId = newId();
+    const inner = { name: 'inner' };
+    const target = {
+      toJSON: () => ({ nestedRef: encodeRef(innerId) }),
+    };
+    const replacer = Json.createRefReplacer({ db: makeStubDb({ [outerId]: target, [innerId]: inner }), depth: 2 });
+    expect(stringifyWith(replacer, { ref: encodeRef(outerId) })).toEqual({
+      ref: { nestedRef: inner },
+    });
+  });
+
+  test('depth budget counts ref hops, not tree depth — a ref deep in a plain tree still resolves', () => {
+    // A ref nested under arbitrarily many plain objects is one ref hop from the root, so
+    // `depth: 1` resolves it. `depth: 0` leaves it encoded.
+    const innerId = newId();
+    const inner = { name: 'inner' };
+    const subject = { a: { b: { c: { d: { ref: encodeRef(innerId) } } } } };
+
+    const inlining = Json.createRefReplacer({ db: makeStubDb({ [innerId]: inner }), depth: 1 });
+    expect(stringifyWith(inlining, subject)).toEqual({ a: { b: { c: { d: { ref: inner } } } } });
+
+    const passthrough = Json.createRefReplacer({ db: makeStubDb({ [innerId]: inner }), depth: 0 });
+    expect(stringifyWith(passthrough, subject)).toEqual(subject);
+  });
+
+  test('inlines refs when invoked through safeStringify (production path)', () => {
+    // `JsonHighlighter` runs the replacer through `@dxos/util/safeStringify`, whose inner
+    // wrapper short-circuits the root call without forwarding it to the user's filter. The
+    // replacer must therefore work on a per-call basis — not as a one-shot root tree walk.
+    // This regression-tests that integration: the `content` ref must inline.
+    const targetId = newId();
+    const target = { toJSON: () => ({ name: 'README content' }) };
+    const document = { id: '01ABC', name: 'README', content: encodeRef(targetId) };
+
+    const replacer = Json.createRefReplacer({ db: makeStubDb({ [targetId]: target }) });
+    const out = JSON.parse(safeStringify(document, replacer, 0)!);
+
+    expect(out).toEqual({ id: '01ABC', name: 'README', content: { name: 'README content' } });
+  });
+});

package/src/Json.ts

@@ -0,0 +1,103 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { EID } from '@dxos/keys';
+
+import * as Database from './Database';
+import * as Obj from './Obj';
+
+/**
+ * `JSON.stringify` replacer signature.
+ *
+ * Defined here (rather than re-imported from a UI package) so other ECHO-aware utilities can
+ * share a stable signature without creating a dependency edge into the UI tree.
+ */
+export type JsonReplacer = (key: string, value: any) => any;
+
+export type CreateRefReplacerOptions = {
+  db: Database.Database;
+  /** How many ref hops to follow. `0` leaves all refs as-is. Default: `1`. */
+  depth?: number;
+};
+
+const isEncodedRef = (value: unknown): value is { '/': string } =>
+  typeof value === 'object' &&
+  value !== null &&
+  Object.keys(value as object).length === 1 &&
+  typeof (value as { '/': unknown })['/'] === 'string';
+
+const toJson = (obj: Obj.Any): unknown => (typeof (obj as any).toJSON === 'function' ? (obj as any).toJSON() : obj);
+
+/**
+ * Returns a {@link JsonReplacer} that inlines ECHO ref objects (`{ "/": "echo:..." }`) up to
+ * `depth` ref hops. Beyond that depth refs are left in their encoded form.
+ *
+ * Implemented as a per-call `JSON.stringify` replacer (not a one-shot tree walk at root) so it
+ * composes with wrappers like `safeStringify` that intercept the root call. JSON.stringify
+ * already drives the recursion; we only need to (a) detect a ref at the current callback,
+ * (b) resolve and return the target if hop budget remains, and (c) tag the returned object
+ * with its hop count so children know how far in they are.
+ *
+ * The hop count is tracked per-object via a `WeakMap`: a ref-resolved target's children inherit
+ * `parentHops + 1`; a regular intermediate object's children inherit `parentHops`. This makes the
+ * budget count *ref hops*, not tree depth — a ref deep in a tree still resolves once when
+ * `depth >= 1`.
+ *
+ * Note: ECHO objects' `toJSON` runs before the replacer is invoked, so by the time we see a
+ * value refs are already encoded as `{ "/": "dxn:..." }`.
+ */
+export const createRefReplacer = ({ db, depth = 1 }: CreateRefReplacerOptions): JsonReplacer => {
+  // Per-object hop count. Set when we return an object (via ref resolution or pass-through) so
+  // the child callbacks (which carry that object as `this`) can read it.
+  const hops = new WeakMap<object, number>();
+
+  return function (this: any, key: string, value: any) {
+    // Hop count for this call: hops at the parent, or 0 for the root.
+    const parentHops = this && typeof this === 'object' ? (hops.get(this) ?? 0) : 0;
+    if (isEncodedRef(value)) {
+      if (parentHops >= depth) {
+        return value;
+      }
+
+      // The `{ '/': string }` shape is shared with non-DXN IPLD-style refs (e.g. CIDs);
+      // an unparseable string would otherwise crash the whole `JSON.stringify`.
+      // Treat any parse miss as "leave as-is" rather than propagating.
+      const dxnString = value['/'];
+      if (!dxnString.startsWith('dxn:') && !dxnString.startsWith('echo:')) {
+        return value;
+      }
+
+      let echoUri: string | undefined;
+      try {
+        const parsed = EID.tryParse(dxnString);
+        echoUri = parsed ? EID.getEntityId(parsed) : undefined;
+      } catch {
+        return value;
+      }
+
+      if (!echoUri) {
+        return value;
+      }
+      const target = db.getObjectById(echoUri);
+      if (!target) {
+        return value;
+      }
+
+      const encoded = toJson(target);
+      if (encoded != null && typeof encoded === 'object') {
+        // Children of the resolved target are one hop deeper.
+        hops.set(encoded as object, parentHops + 1);
+      }
+      return encoded;
+    }
+
+    // Pass-through object: children inherit the parent's hop count (this branch doesn't burn
+    // budget).
+    if (value != null && typeof value === 'object') {
+      hops.set(value, parentHops);
+    }
+
+    return value;
+  };
+};

package/src/Key.ts

@@ -5,4 +5,4 @@
 // TODO(wittjosiah): Should this be a subset of Type?
 
 export { ForeignKey } from '@dxos/echo-protocol';
-export { SpaceId, ObjectId } from '@dxos/keys';
+export { EID, EntityId, SpaceId, URI } from '@dxos/keys';

package/src/Migration.ts

@@ -6,23 +6,41 @@
 
 import type * as Schema from 'effect/Schema';
 
-import { type DXN } from '@dxos/keys';
+import { type URI } from '@dxos/keys';
 
 import type * as Database from './Database';
 import type * as Entity from './Entity';
-import { getSchemaDXN } from './internal';
+import { MetaId, type EntityMeta, getSchemaURI } from './internal';
+import * as Type from './Type';
 
-type DefineObjectMigrationOptions<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {
+/**
+ * Result returned by a migration's `transform` callback.
+ * The data shape matches the target schema; the optional `[Obj.Meta]` symbol key lets the
+ * transform update the object's meta (e.g. `key` / `version`) atomically with the data swap.
+ */
+type MigrationSchemaInput = Type.AnyEntity;
+
+type MigrationInstanceType<S> = S extends Type.AnyEntity
+  ? Type.InstanceType<S>
+  : S extends Schema.Schema.AnyNoContext
+    ? Schema.Schema.Type<S>
+    : never;
+
+export type TransformResult<To> = Omit<MigrationInstanceType<To>, 'id' | Entity.KindId> & {
+  [MetaId]?: Partial<EntityMeta>;
+};
+
+type DefineObjectMigrationOptions<From extends MigrationSchemaInput, To extends MigrationSchemaInput> = {
   from: From;
   to: To;
   /**
    * Pure function that converts the old object data to the new object data.
+   *
+   * The returned object may include an optional `[Obj.Meta]` entry to update the object's meta
+   * (e.g. registry `key` / `version`) atomically with the data swap.
    */
   // TODO(dmaretskyi): `id` should not be a part of the schema.
-  transform: (
-    from: Schema.Schema.Type<From>,
-    context: ObjectMigrationContext,
-  ) => Promise<Omit<Schema.Schema.Type<To>, 'id' | Entity.KindId>>;
+  transform: (from: MigrationInstanceType<From>, context: ObjectMigrationContext) => Promise<TransformResult<To>>;
 
   /**
    * Callback that is called after the object is migrated. Called for every object that is migrated.
@@ -30,7 +48,7 @@ type DefineObjectMigrationOptions<From extends Schema.Schema.AnyNoContext, To ex
    * NOTE: Database mutations performed in this callback are not guaranteed to be idempotent.
    *       If multiple peers run the migration separately, the effects may be applied multiple times.
    */
-  onMigration: (params: OnMigrateProps<From, To>) => Promise<void>;
+  onMigration?: (params: OnMigrateProps<From, To>) => Promise<void>;
 };
 
 /**
@@ -40,9 +58,9 @@ export type ObjectMigrationContext = {
   db: Database.Database;
 };
 
-type OnMigrateProps<From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext> = {
-  before: Schema.Schema.Type<From>;
-  object: Schema.Schema.Type<To>;
+type OnMigrateProps<From, To> = {
+  before: MigrationInstanceType<From>;
+  object: MigrationInstanceType<To>;
   db: Database.Database;
 };
 
@@ -50,12 +68,12 @@ type OnMigrateProps<From extends Schema.Schema.AnyNoContext, To extends Schema.S
  * Definition of a migration from one object schema version to another.
  */
 export type ObjectMigration = {
-  fromType: DXN;
-  toType: DXN;
+  fromType: URI.URI;
+  toType: URI.URI;
   fromSchema: Schema.Schema.AnyNoContext;
   toSchema: Schema.Schema.AnyNoContext;
   transform: (from: unknown, context: ObjectMigrationContext) => Promise<unknown>;
-  onMigration: (params: OnMigrateProps<any, any>) => Promise<void>;
+  onMigration?: (params: OnMigrateProps<any, any>) => Promise<void>;
 };
 
 /**
@@ -71,14 +89,16 @@ export type ObjectMigration = {
  * });
  * ```
  */
-export const define = <From extends Schema.Schema.AnyNoContext, To extends Schema.Schema.AnyNoContext>(
+export const define = <From extends MigrationSchemaInput, To extends MigrationSchemaInput>(
   options: DefineObjectMigrationOptions<From, To>,
 ): ObjectMigration => {
-  const fromType = getSchemaDXN(options.from);
+  const fromSchema = Type.getSchema(options.from);
+  const toSchema = Type.getSchema(options.to);
+  const fromType = getSchemaURI(fromSchema);
   if (!fromType) {
     throw new Error('Invalid from schema');
   }
-  const toType = getSchemaDXN(options.to);
+  const toType = getSchemaURI(toSchema);
   if (!toType) {
     throw new Error('Invalid to schema');
   }
@@ -86,8 +106,8 @@ export const define = <From extends Schema.Schema.AnyNoContext, To extends Schem
   return {
     fromType,
     toType,
-    fromSchema: options.from,
-    toSchema: options.to,
+    fromSchema,
+    toSchema,
     transform: options.transform as any,
     onMigration: options.onMigration as any,
   };