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

package/dist/types/src/JsonSchema.d.ts

@@ -1,9 +1,16 @@
 import type * as Schema from 'effect/Schema';
-import { JsonSchemaType } from './internal';
-export { toEffectSchema, toJsonSchema } from './internal';
+import * as jsonSchemaInternal from './internal/JsonSchema';
+/**
+ * Decode JSON Schema to Effect Schema.
+ */
+export declare const toEffectSchema: (root: jsonSchemaInternal.JsonSchemaType, _defs?: jsonSchemaInternal.JsonSchemaType['$defs']) => Schema.Schema.AnyNoContext;
+/**
+ * Encode Effect Schema to JSON Schema.
+ */
+export declare const toJsonSchema: (schema: Schema.Schema.All | import("./Type").AnyEntity, options?: jsonSchemaInternal.JsonSchemaOptions) => import("effect/Types").DeepMutable<jsonSchemaInternal.JsonSchemaType>;
 /**
  * Serializable JsonSchema type definition.
  */
-export type JsonSchema = JsonSchemaType;
-export declare const JsonSchema: Schema.Schema<JsonSchemaType>;
+export type JsonSchema = jsonSchemaInternal.JsonSchemaType;
+export declare const JsonSchema: Schema.Schema<jsonSchemaInternal.JsonSchemaType>;
 //# sourceMappingURL=JsonSchema.d.ts.map

package/dist/types/src/JsonSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"JsonSchema.d.ts","sourceRoot":"","sources":["../../../src/JsonSchema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC;AAExC,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,cAAc,CAAkB,CAAC"}
+{"version":3,"file":"JsonSchema.d.ts","sourceRoot":"","sources":["../../../src/JsonSchema.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,kBAAkB,MAAM,uBAAuB,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,cAAc,6HAAoC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,YAAY,mLAAkC,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,kBAAkB,CAAC,cAAc,CAAC;AAE3D,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,cAAc,CAAqC,CAAC"}

package/dist/types/src/Key.d.ts

@@ -1,3 +1,3 @@
 export { ForeignKey } from '@dxos/echo-protocol';
-export { SpaceId, ObjectId } from '@dxos/keys';
+export { EchoURI, ObjectId, SpaceId, URI } from '@dxos/keys';
 //# sourceMappingURL=Key.d.ts.map

package/dist/types/src/Key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Key.d.ts","sourceRoot":"","sources":["../../../src/Key.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"Key.d.ts","sourceRoot":"","sources":["../../../src/Key.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC"}

package/dist/types/src/Migration.d.ts

@@ -0,0 +1,72 @@
+import type * as Schema from 'effect/Schema';
+import { type URI } from '@dxos/keys';
+import type * as Database from './Database';
+import type * as Entity from './Entity';
+import { MetaId, type ObjectMeta } from './internal';
+import * as Type from './Type';
+/**
+ * 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<ObjectMeta>;
+};
+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.
+     */
+    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.
+     *
+     * 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>;
+};
+/**
+ * Context passed to object migration callbacks.
+ */
+export type ObjectMigrationContext = {
+    db: Database.Database;
+};
+type OnMigrateProps<From, To> = {
+    before: MigrationInstanceType<From>;
+    object: MigrationInstanceType<To>;
+    db: Database.Database;
+};
+/**
+ * Definition of a migration from one object schema version to another.
+ */
+export type ObjectMigration = {
+    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>;
+};
+/**
+ * Define a migration between two object schemas.
+ *
+ * @example
+ * ```ts
+ * const migration = Migration.define({
+ *   from: ContactV1,
+ *   to: ContactV2,
+ *   transform: async (from) => ({ name: `${from.firstName} ${from.lastName}` }),
+ *   onMigration: async () => {},
+ * });
+ * ```
+ */
+export declare const define: <From extends MigrationSchemaInput, To extends MigrationSchemaInput>(options: DefineObjectMigrationOptions<From, To>) => ObjectMigration;
+export {};
+//# sourceMappingURL=Migration.d.ts.map

package/dist/types/src/Migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Migration.d.ts","sourceRoot":"","sources":["../../../src/Migration.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAE7C,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,KAAK,QAAQ,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,KAAK,MAAM,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,KAAK,UAAU,EAAgB,MAAM,YAAY,CAAC;AACnE,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAE/B;;;;GAIG;AACH,KAAK,oBAAoB,GAAG,IAAI,CAAC,SAAS,CAAC;AAE3C,KAAK,qBAAqB,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,GACpD,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GACpB,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,YAAY,GAClC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,GACrB,KAAK,CAAC;AAEZ,MAAM,MAAM,eAAe,CAAC,EAAE,IAAI,IAAI,CAAC,qBAAqB,CAAC,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG;IACxF,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;CAChC,CAAC;AAEF,KAAK,4BAA4B,CAAC,IAAI,SAAS,oBAAoB,EAAE,EAAE,SAAS,oBAAoB,IAAI;IACtG,IAAI,EAAE,IAAI,CAAC;IACX,EAAE,EAAE,EAAE,CAAC;IACP;;;;;OAKG;IAEH,SAAS,EAAE,CAAC,IAAI,EAAE,qBAAqB,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC;IAEhH;;;;;OAKG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC;CACvB,CAAC;AAEF,KAAK,cAAc,CAAC,IAAI,EAAE,EAAE,IAAI;IAC9B,MAAM,EAAE,qBAAqB,CAAC,IAAI,CAAC,CAAC;IACpC,MAAM,EAAE,qBAAqB,CAAC,EAAE,CAAC,CAAC;IAClC,EAAE,EAAE,QAAQ,CAAC,QAAQ,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,GAAG,CAAC,GAAG,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IACvC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IACrC,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAChF,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,GAAI,IAAI,SAAS,oBAAoB,EAAE,EAAE,SAAS,oBAAoB,WAC9E,4BAA4B,CAAC,IAAI,EAAE,EAAE,CAAC,KAC9C,eAoBF,CAAC"}

package/dist/types/src/Obj.d.ts

@@ -1,20 +1,22 @@
-import * as Schema from 'effect/Schema';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
 import type { ForeignKey } from '@dxos/echo-protocol';
-import { type DXN, ObjectId } from '@dxos/keys';
+import { ObjectId, type URI } from '@dxos/keys';
 import type * as Database from './Database';
 import * as Entity from './Entity';
-import { type ObjectJSON as APIJSON, type AnyEntity, type AnyProperties, type Comparator as ApiComparator, type Meta as ApiMeta, type ReadonlyMeta as ApiReadonlyMeta, type EntityVersion as ApiVersion, type ChangeCallback, type KindId, type Mutable, type ObjectMeta, type SnapshotKindId, type VersionCompareResult, VersionTypeId, compareVersions, decodeVersion, encodeVersion, isVersion, versionValid } from './internal';
-import type * as Ref from './Ref';
-import type * as Type from './Type';
+import * as Err from './Err';
+import * as internal from './internal';
+import * as Ref from './Ref';
+import * as Type from './Type';
 /**
  * Base type for all ECHO objects.
  */
-interface BaseObj extends AnyEntity, Entity.OfKind<typeof Entity.Kind.Object> {
+interface BaseObj extends internal.AnyEntity, Entity.OfKind<typeof Entity.Kind.Object> {
 }
 /**
  * Object type with specific properties.
  */
-export type Obj<Props> = BaseObj & Props;
+export type OfShape<Props> = BaseObj & Props;
 /**
  * Object with no known properties beyond id and kind.
  * Use this when the object's schema/properties are not known.
@@ -25,6 +27,28 @@ export type Obj<Props> = BaseObj & Props;
  */
 export interface Unknown extends BaseObj {
 }
+/**
+ * Runtime Effect schema for any ECHO object.
+ * Use for validation, parsing, or as a reference target for collections.
+ *
+ * NOTE: `Schema.is(Type.Obj)` does STRUCTURAL validation only (checks for `id` field).
+ * Use `Obj.isObject()` for proper ECHO instance type guards that check the KindId brand.
+ *
+ * @example
+ * ```ts
+ * // Structural type guard (accepts any object with id field)
+ * if (Schema.is(Type.Obj)(unknownValue)) { ... }
+ *
+ * // ECHO instance type guard (checks KindId brand)
+ * if (Obj.isObject(unknownValue)) { ... }
+ *
+ * // Reference to any object type
+ * const Collection = Schema.Struct({
+ *   objects: Schema.Array(Ref.Ref(Obj.Unknown)),
+ * }).pipe(Type.makeObject(DXN.make('com.example.type.collection', '0.1.0')));
+ * ```
+ */
+export declare const Unknown: internal.UnknownTypeSchema<Unknown, typeof Entity.Kind.Object>;
 /**
  * Object with arbitrary properties.
  *
@@ -33,13 +57,13 @@ export interface Unknown extends BaseObj {
  *
  * Prefer using `Obj.Unknown` when you don't need to access arbitrary properties.
  */
-export interface Any extends BaseObj, AnyProperties {
+export interface Any extends BaseObj, internal.AnyProperties {
 }
 /**
  * Base type for snapshot objects (has SnapshotKindId instead of KindId).
  */
-interface BaseSnapshot extends AnyEntity {
-    readonly [SnapshotKindId]: typeof Entity.Kind.Object;
+interface BaseSnapshot extends internal.AnyEntity {
+    readonly [Entity.SnapshotKindId]: typeof Entity.Kind.Object;
     readonly id: ObjectId;
 }
 /**
@@ -51,24 +75,33 @@ interface BaseSnapshot extends AnyEntity {
  * Snapshots are structurally identical to reactive objects but have a different brand,
  * making them distinguishable at the TypeScript level. Neither is assignable to the other.
  */
-export type Snapshot<T extends Unknown = Unknown> = Omit<T, KindId> & BaseSnapshot;
-type Props<T = any> = {
-    id?: ObjectId;
-    [Meta]?: Partial<ObjectMeta>;
-} & Type.Properties<T>;
+export type Snapshot<T extends Unknown = Unknown> = Omit<T, Entity.KindId> & BaseSnapshot;
+/**
+ * JSON-encoded properties for objects.
+ */
+export interface BaseObjJson {
+    id: string;
+}
 /**
- * Props type for object creation with a given schema.
+ * Props type for object creation with a given type. Accepts a `Type.AnyObj`
+ * entity and derives the instance shape via `Type.InstanceType`. Relation-kind
+ * entities are rejected at the type level — use `Relation.MakeProps` for those.
+ *
+ * When the schema is the unconstrained `Type.AnyObj` (`Obj<unknown>` — e.g. a
+ * dynamic type from `schemaRegistry.register`), the instance shape is not
+ * statically known, so data props widen to `Record<string, unknown>` and the
+ * caller can pass arbitrary fields without a cast.
  */
-export type MakeProps<S extends Schema.Schema.AnyNoContext> = {
+export type MakeProps<S extends Type.AnyObj> = {
     id?: ObjectId;
-    [Meta]?: Partial<ObjectMeta>;
     [Parent]?: Unknown;
-} & NoInfer<Props<Schema.Schema.Type<S>>>;
+} & ([keyof Entity.Properties<Type.InstanceType<S>>] extends [never] ? Record<string, unknown> : Entity.Properties<Type.InstanceType<S>>);
 /**
- * Creates a new echo object of the given schema.
- * @param schema - Object schema.
+ * Creates a new echo object of the given schema or `Type.Type`.
+ *
+ * @param typeOrSchema - A static object schema (`Type.makeObject(...)`) or a
+ *   `Type.Type` entity (e.g. one returned by `db.schemaRegistry.register`).
  * @param props - Object properties.
- * @param meta - Object metadata (deprecated) -- pass with Obj.Meta.
  *
  * Meta can be passed as a symbol in `props`.
  *
@@ -77,19 +110,15 @@ export type MakeProps<S extends Schema.Schema.AnyNoContext> = {
  * const obj = Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' });
  * ```
  *
- * Note: Only accepts object schemas, not relation schemas. Use `Relation.make` for relations.
+ * Note: Only accepts object schemas / object-kind types, not relation schemas.
+ * Use `Relation.make` for relations.
  */
-export declare const make: {
-    <S extends Type.Obj.Any>(schema: S, props: MakeProps<S>): Obj<Schema.Schema.Type<S>>;
-    /**
-     * @deprecated Pass meta as in the example: `Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' })`.
-     */
-    <S extends Type.Obj.Any>(schema: S, props: MakeProps<S>, meta: Partial<ObjectMeta>): Obj<Schema.Schema.Type<S>>;
-};
+export declare function make<T extends Type.AnyObj>(type: T, props: NoInfer<MakeProps<T>>): OfShape<Type.InstanceType<T>>;
 /**
  * Determine if object is an ECHO object.
  */
 export declare const isObject: (obj: unknown) => obj is Unknown;
+export declare const isSnapshot: (obj: unknown) => obj is Snapshot;
 /**
  * Subscribe to object updates.
  * The callback is called synchronously when the object is modified.
@@ -103,6 +132,41 @@ export declare const subscribe: (obj: Unknown, callback: () => void) => (() => v
  * making it distinguishable from the reactive object at the type level.
  */
 export declare const getSnapshot: <T extends Unknown>(obj: T) => Snapshot<T>;
+/**
+ * Returns the reactive version of an object from the database, given its snapshot.
+ * Inverse of `Obj.getSnapshot`.
+ *
+ * Uses `Obj.getDatabase` internally to get the database from the snapshot,
+ * then resolves the reactive object by ID.
+ *
+ * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).
+ * @returns Effect that succeeds with the reactive object, or fails with `GetReactiveError`.
+ * @example
+ * ```ts
+ * const snapshot = Obj.getSnapshot(obj);
+ * const reactive = Obj.getReactive(snapshot).pipe(
+ *   Effect.runSync
+ * );
+ * ```
+ */
+export declare const getReactive: <T extends Unknown>(snapshot: Snapshot<T>) => Effect.Effect<T, Err.GetReactiveError>;
+/**
+ * Like `Obj.getReactive` but returns `Option.none()` instead of failing when the object
+ * cannot be resolved (no database, object not found).
+ *
+ * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).
+ * @returns Effect that succeeds with `Option.some(reactive)` or `Option.none()`.
+ */
+export declare const getReactiveOption: <T extends Unknown>(snapshot: Snapshot<T>) => Effect.Effect<Option.Option<T>, never>;
+/**
+ * Synchronous version of `Obj.getReactive`. Returns the reactive object or throws
+ * `GetReactiveError` when the object cannot be resolved (no database, object not found).
+ *
+ * @param snapshot - A snapshot of the object (from `Obj.getSnapshot`).
+ * @returns The reactive object.
+ * @throws {Err.GetReactiveError} When the object cannot be resolved.
+ */
+export declare const getReactiveOrThrow: <T extends Unknown>(snapshot: Snapshot<T>) => T;
 export type CloneOptions = {
     /**
      * Retain the original object's ID.
@@ -123,40 +187,40 @@ export type CloneOptions = {
 export declare const clone: <T extends Unknown>(obj: T, opts?: CloneOptions) => T;
 /**
  * Makes all properties mutable recursively.
- * Used to provide a mutable view of an object within `Obj.change`.
+ * Used to provide a mutable view of an object within `Obj.update`.
  */
-export type { Mutable };
+export type Mutable<T> = internal.Mutable<T>;
 /**
  * Perform mutations on an echo object within a controlled context.
  *
  * All mutations within the callback are batched and trigger a single notification
- * when the callback completes. Direct mutations outside of `Obj.change` will throw
+ * when the callback completes. Direct mutations outside of `Obj.update` will throw
  * an error for echo objects.
  *
  * This function also works with nested objects within echo objects (e.g., Template structs)
  * that are reactive at runtime.
  *
- * @param obj - The echo object to mutate. Use `Relation.change` for relations.
+ * @param obj - The echo object to mutate. Use `Relation.update` for relations.
  * @param callback - The callback that performs mutations on the object.
  *
  * @example
  * ```ts
  * const person = Obj.make(Person, { name: 'John', age: 25 });
  *
- * // Mutate within Obj.change
- * Obj.change(person, (p) => {
- *   p.name = 'Jane';
- *   p.age = 30;
+ * // Mutate within Obj.update
+ * Obj.update(person, (obj) => {
+ *   obj.name = 'Jane';
+ *   obj.age = 30;
  * });
  * // ONE notification fires here
  *
  * // Direct mutation throws
- * person.name = 'Bob'; // Error: Cannot modify outside Obj.change()
+ * person.name = 'Bob'; // Error: Cannot modify outside Obj.update()
  * ```
  *
- * Note: Only accepts objects. Use `Relation.change` for relations.
+ * Note: Only accepts objects. Use `Relation.update` for relations.
  */
-export declare const change: <T extends Unknown>(obj: T, callback: ChangeCallback<T>) => void;
+export declare const update: <T extends Unknown>(obj: T, callback: internal.ChangeCallback<T>) => void;
 /**
  * Get a deeply nested property from an object.
  *
@@ -185,7 +249,7 @@ export declare const getValue: (obj: Unknown | Snapshot, path: readonly (string
  * whether to initialize nested data as an empty object or array.
  *
  * Similar to lodash.set and setDeep from @dxos/util, but schema-aware.
- * Must be called within an `Obj.change` callback.
+ * Must be called within an `Obj.update` callback.
  *
  * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
  * parameters, so there is no compile-time error. Enforcement is runtime-only.
@@ -199,8 +263,8 @@ export declare const getValue: (obj: Unknown | Snapshot, path: readonly (string
  * ```ts
  * const person = Obj.make(Person, { name: 'John' });
  * // Person schema has: addresses: Schema.Array(Address)
- * Obj.change(person, (p) => {
- *   Obj.setValue(p, ['addresses', 0, 'street'], '123 Main St');
+ * Obj.update(person, (obj) => {
+ *   Obj.setValue(obj, ['addresses', 0, 'street'], '123 Main St');
  * });
  * // Creates: person.addresses = [{ street: '123 Main St' }]
  * ```
@@ -209,7 +273,8 @@ export declare const setValue: (obj: Mutable<Unknown>, path: readonly (string |
 export declare const ID: import("@dxos/keys").ObjectIdClass;
 export type ID = ObjectId;
 /**
- * Test if object or relation is an instance of a schema.
+ * Test if an object is an instance of a given object type.
+ *
  * @example
  * ```ts
  * const john = Obj.make(Person, { name: 'John' });
@@ -218,30 +283,59 @@ export type ID = ObjectId;
  *   // john is Person
  * }
  * ```
+ *
+ * Only accepts `Type.AnyObj` — use `Relation.instanceOf` for relations and
+ * `Type.isType(value)` to test for `Type.Type` meta-schema entities.
  */
 export declare const instanceOf: {
-    <S extends Type.Entity.Any>(schema: S): (value: unknown) => value is Schema.Schema.Type<S>;
-    <S extends Type.Entity.Any>(schema: S, value: unknown): value is Schema.Schema.Type<S>;
+    <T extends Type.Type>(type: T, _hint?: never, ..._error: ['ERROR: Obj.instanceOf does not accept Type.Type; use Type.isType(value) instead']): never;
+    <R extends Type.AnyRelation>(type: R, _hint?: never, ..._error: ['ERROR: Obj.instanceOf does not accept relation types; use Relation.instanceOf instead']): never;
+    <S extends Type.AnyObj>(schema: S): (value: unknown) => value is Type.InstanceType<S>;
+    <S extends Type.AnyObj>(schema: S, value: unknown): value is Type.InstanceType<S>;
 };
 /**
- * Get the DXN of the object.
+ * Test if a snapshot is an instance of a schema.
+ * Mirrors `instanceOf` but only accepts values branded with SnapshotKindId.
+ * Use when the value is known to be a snapshot (e.g. from `getSnapshot` or `useObject`).
+ *
+ * @example
+ * ```ts
+ * const snapshot = Obj.getSnapshot(person);
+ * if (Obj.snapshotOf(Person, snapshot)) {
+ *   // snapshot is Obj.Snapshot<Person>
+ * }
+ * ```
+ */
+export declare const snapshotOf: {
+    <S extends Type.AnyObj>(schema: S): (value: unknown) => value is Snapshot<Type.InstanceType<S>>;
+    <S extends Type.AnyObj>(schema: S, value: unknown): value is Snapshot<Type.InstanceType<S>>;
+};
+/**
+ * Get the canonical URI of the object. Returns `URI.URI` (today always an EchoURI,
+ * but future entity kinds may surface other URI schemes — narrow with
+ * `EchoURI.parse(uri)` or `DXN.tryMake(uri)` at the point of use).
  * Accepts both reactive objects and snapshots.
  */
-export declare const getDXN: (entity: Unknown | Snapshot) => DXN;
+export declare const getURI: (entity: Unknown | Snapshot) => URI.URI;
 /**
  * @returns The DXN of the object's type.
- * @example dxn:example.com/type/Person:1.0.0
+ * @example dxn:com.example.type.person:1.0.0
+ * @throws If the object is missing its type (corrupted object).
  */
-export declare const getTypeDXN: (obj: unknown | undefined) => DXN | undefined;
+export declare const getTypeURI: (obj: Unknown | Snapshot) => URI.URI;
 /**
- * Get the schema of the object.
- * Returns the branded ECHO schema used to create the object.
+ * Get the type entity (`Type.AnyObj`) the object was created from.
+ *
+ * Returns `undefined` when the object'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 object loaded from storage before its schema is known). To
+ * get the Effect Schema from the returned entity, use `Type.getSchema(...)`.
  */
-export declare const getSchema: (obj: unknown | undefined) => Type.Entity.Any | undefined;
+export declare const getType: (obj: Unknown | Snapshot) => Type.AnyObj | undefined;
 /**
  * @returns The typename of the object's type.
  * Accepts both reactive objects and snapshots.
- * @example `example.com/type/Person`
+ * @example `com.example.type.person`
  */
 export declare const getTypename: (entity: Unknown | Snapshot) => string | undefined;
 /**
@@ -249,19 +343,24 @@ export declare const getTypename: (entity: Unknown | Snapshot) => string | undef
  * Accepts both reactive objects and snapshots.
  */
 export declare const getDatabase: (entity: Entity.Unknown | Entity.Snapshot) => Database.Database | undefined;
-export declare const Meta: unique symbol;
+/**
+ * Property that accesses metadata for an entity.
+ *
+ * Alias for `Entity.Meta`.
+ */
+export declare const Meta: symbol;
 /**
  * Deeply read-only version of ObjectMeta.
  * Prevents mutation at all nesting levels (e.g., `meta.keys.push()` is a TypeScript error).
  */
-export type ReadonlyMeta = ApiReadonlyMeta;
+export type ReadonlyMeta = internal.ReadonlyMeta;
 /**
- * Mutable meta type returned by `Obj.getMeta` inside an `Obj.change` callback.
+ * Mutable meta type returned by `Obj.getMeta` inside an `Obj.update` callback.
  */
-export type Meta = ApiMeta;
+export type Meta = internal.Meta;
 /**
  * Get the metadata for an object.
- * Returns mutable meta when passed a mutable object (inside `Obj.change` callback).
+ * Returns mutable meta when passed a mutable object (inside `Obj.update` callback).
  * Returns read-only meta when passed a regular object or snapshot.
  *
  * @example
@@ -270,8 +369,8 @@ export type Meta = ApiMeta;
  * const meta = Obj.getMeta(person);  // ReadonlyMeta
  *
  * // Mutable access inside change callback
- * Obj.change(person, (p) => {
- *   const meta = Obj.getMeta(p);     // ObjectMeta (mutable)
+ * Obj.update(person, (obj) => {
+ *   const meta = Obj.getMeta(obj);     // ObjectMeta (mutable)
  *   meta.tags ??= [];
  *   meta.tags.push('important');
  * });
@@ -289,7 +388,7 @@ export declare const getKeys: {
 };
 /**
  * Delete all keys from the object for the specified source.
- * Must be called within an `Obj.change` callback.
+ * Must be called within an `Obj.update` callback.
  *
  * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
  * parameters, so there is no compile-time error. Enforcement is runtime-only.
@@ -297,7 +396,7 @@ export declare const getKeys: {
 export declare const deleteKeys: (entity: Mutable<Unknown>, source: string) => void;
 /**
  * Add a tag to the object.
- * Must be called within an `Obj.change` callback.
+ * Must be called within an `Obj.update` callback.
  *
  * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
  * parameters, so there is no compile-time error. Enforcement is runtime-only.
@@ -305,7 +404,7 @@ export declare const deleteKeys: (entity: Mutable<Unknown>, source: string) => v
 export declare const addTag: (entity: Mutable<Unknown>, tag: string) => void;
 /**
  * Remove a tag from the object.
- * Must be called within an `Obj.change` callback.
+ * Must be called within an `Obj.update` callback.
  *
  * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
  * parameters, so there is no compile-time error. Enforcement is runtime-only.
@@ -319,11 +418,14 @@ export declare const isDeleted: (entity: Unknown | Snapshot) => boolean;
 /**
  * Get the label of the object.
  * Accepts both reactive objects and snapshots.
+ *
+ * @param options.fallback `'typename'` returns the object's typename when no
+ *   label is set (e.g. `org.dxos.type.table`).
  */
-export declare const getLabel: (entity: Unknown | Snapshot) => string | undefined;
+export declare const getLabel: (entity: Unknown | Snapshot, options?: internal.GetLabelOptions) => string | undefined;
 /**
  * Set the label of the object.
- * Must be called within an `Obj.change` callback.
+ * Must be called within an `Obj.update` callback.
  *
  * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
  * parameters, so there is no compile-time error. Enforcement is runtime-only.
@@ -336,7 +438,7 @@ export declare const setLabel: (entity: Mutable<Unknown>, label: string) => void
 export declare const getDescription: (entity: Unknown | Snapshot) => string | undefined;
 /**
  * Set the description of the object.
- * Must be called within an `Obj.change` callback.
+ * Must be called within an `Obj.update` callback.
  *
  * NOTE: TypeScript's structural typing allows readonly objects to be passed to `Mutable<T>`
  * parameters, so there is no compile-time error. Enforcement is runtime-only.
@@ -365,11 +467,25 @@ export declare const getParent: (entity: Unknown | Snapshot) => Unknown | undefi
  * If a parent (or any transitive parent) is deleted, the object will be deleted.
  * Only objects are allowed to have a parent.
  */
-export declare const setParent: (entity: Unknown, parent: Any | undefined) => void;
+export declare const setParent: (entity: Unknown, parent: Any | undefined) => Unknown & internal.InternalObjectProps;
+interface UpdateFromOptions<T> {
+    exclude?: (keyof T)[];
+    include?: (keyof T)[];
+}
+/**
+ * For each key present on `source` (except `id`), assigns `target[key]` when the current value differs.
+ * References are compared by target DXN; other values use Effect `Equal.equals` inside a structural region,
+ * with recursive comparison for arrays and plain object-shaped property bags (excluding `id`).
+ *
+ * Must be called within an `Obj.update` callback.
+ *
+ * @returns Whether any property was updated.
+ */
+export declare const updateFrom: <T extends Unknown>(target: Mutable<T>, source: T, options?: UpdateFromOptions<T>) => boolean;
 /**
  * JSON representation of an object.
  */
-export type JSON = APIJSON;
+export type JSON = internal.ObjectJSON;
 /**
  * Converts object to its JSON representation.
  * Accepts both reactive objects and snapshots.
@@ -384,32 +500,40 @@ export declare const toJSON: (entity: Unknown | Snapshot) => JSON;
  * The function must be async to support resolving the schema as well as the relation endpoints.
  *
  * @param options.refResolver - Resolver for references. Produces hydrated references that can be resolved.
- * @param options.dxn - Override object DXN. Changes the result of `Obj.getDXN`.
+ * @param options.uri - Override object URI. Changes the result of `Obj.getURI`.
+ * @param options.database - Database to associate with the object.
  */
 export declare const fromJSON: (json: unknown, options?: {
     refResolver?: Ref.Resolver;
-    dxn?: DXN;
+    uri?: URI.URI;
+    database?: Database.Database;
+    parent?: Unknown;
 }) => Promise<Unknown>;
 /**
  * Comparator function type for sorting objects.
  * Accepts both reactive objects and snapshots.
  */
-export type Comparator = ApiComparator<Unknown | Snapshot>;
+export type Comparator = internal.Comparator<Unknown | Snapshot>;
 export declare const sortByLabel: Comparator;
 export declare const sortByTypename: Comparator;
 export declare const sort: (...comparators: Comparator[]) => Comparator;
-export { VersionTypeId };
-export type { VersionCompareResult };
+export declare const VersionTypeId: "~@dxos/echo/VersionTypeId";
+export type VersionCompareResult = internal.VersionCompareResult;
 /**
  * Represent object version.
  * May be backed by Automerge.
  * Objects with no history are not versioned.
  */
-export type Version = ApiVersion;
-export { isVersion, versionValid, compareVersions, encodeVersion, decodeVersion };
+export type Version = internal.EntityVersion;
+export declare const isVersion: (entity: unknown) => entity is internal.EntityVersion;
+export declare const versionValid: (ver: internal.EntityVersion) => boolean;
+export declare const compareVersions: (version1: internal.EntityVersion, version2: internal.EntityVersion) => internal.VersionCompareResult;
+export declare const encodeVersion: (ver: internal.EntityVersion) => string;
+export declare const decodeVersion: (ver: string) => internal.EntityVersion;
 /**
  * Returns the version of the object.
  * Accepts both reactive objects and snapshots.
  */
 export declare const version: (entity: Unknown | Snapshot) => Version;
+export {};
 //# sourceMappingURL=Obj.d.ts.map