@dxos/echo 0.8.3 → 0.8.4-main.1da679c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/echo",
-  "version": "0.8.3",
+  "version": "0.8.4-main.1da679c",
   "description": "ECHO API",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -10,31 +10,37 @@
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
     },
     "./Type": {
+      "source": "./src/Type.ts",
       "types": "./dist/types/src/Type.d.ts",
       "browser": "./dist/lib/browser/Type.mjs",
       "node": "./dist/lib/node-esm/Type.mjs"
     },
     "./Obj": {
+      "source": "./src/Obj.ts",
       "types": "./dist/types/src/Obj.d.ts",
       "browser": "./dist/lib/browser/Obj.mjs",
       "node": "./dist/lib/node-esm/Obj.mjs"
     },
     "./Relation": {
+      "source": "./src/Relation.ts",
       "types": "./dist/types/src/Relation.d.ts",
       "browser": "./dist/lib/browser/Relation.mjs",
       "node": "./dist/lib/node-esm/Relation.mjs"
     },
     "./Ref": {
+      "source": "./src/Ref.ts",
       "types": "./dist/types/src/Ref.d.ts",
       "browser": "./dist/lib/browser/Ref.mjs",
       "node": "./dist/lib/node-esm/Ref.mjs"
     },
     "./testing": {
+      "source": "./src/testing/types.ts",
       "types": "./dist/types/src/testing/types.d.ts",
       "browser": "./dist/lib/browser/testing/index.mjs",
       "node": "./dist/lib/node-esm/testing/index.mjs"
@@ -66,18 +72,19 @@
   ],
   "dependencies": {
     "@preact/signals-core": "^1.9.0",
-    "effect": "3.14.21",
-    "@dxos/debug": "0.8.3",
-    "@dxos/echo-schema": "0.8.3",
-    "@dxos/echo-protocol": "0.8.3",
-    "@dxos/echo-signals": "0.8.3",
-    "@dxos/effect": "0.8.3",
-    "@dxos/invariant": "0.8.3",
-    "@dxos/live-object": "0.8.3",
-    "@dxos/keys": "0.8.3",
-    "@dxos/log": "0.8.3",
-    "@dxos/node-std": "0.8.3",
-    "@dxos/util": "0.8.3"
+    "effect": "3.17.7",
+    "@dxos/debug": "0.8.4-main.1da679c",
+    "@dxos/echo-protocol": "0.8.4-main.1da679c",
+    "@dxos/echo-schema": "0.8.4-main.1da679c",
+    "@dxos/echo-signals": "0.8.4-main.1da679c",
+    "@dxos/invariant": "0.8.4-main.1da679c",
+    "@dxos/errors": "0.8.4-main.1da679c",
+    "@dxos/effect": "0.8.4-main.1da679c",
+    "@dxos/keys": "0.8.4-main.1da679c",
+    "@dxos/live-object": "0.8.4-main.1da679c",
+    "@dxos/log": "0.8.4-main.1da679c",
+    "@dxos/util": "0.8.4-main.1da679c",
+    "@dxos/node-std": "0.8.4-main.1da679c"
   },
   "publishConfig": {
     "access": "public"

package/src/Obj.ts

@@ -3,48 +3,72 @@
 //
 
 import { Schema } from 'effect';
+import { dual } from 'effect/Function';
 
 import * as EchoSchema from '@dxos/echo-schema';
 import { assertArgument, invariant } from '@dxos/invariant';
 import { type DXN } from '@dxos/keys';
-import type * as LiveObject from '@dxos/live-object';
+import * as LiveObject from '@dxos/live-object';
 import { live } from '@dxos/live-object';
-import { assumeType } from '@dxos/util';
+import { assumeType, deepMapValues } from '@dxos/util';
 
 import type * as Ref from './Ref';
 import type * as Relation from './Relation';
-import type * as Type from './Type';
+import * as Type from './Type';
 
-// NOTE: Don't export: Obj.Any and Obj.Obj form the public API.
-interface ObjBase extends Type.OfKind<EchoSchema.EntityKind.Object> {
-  readonly id: EchoSchema.ObjectId;
-}
+/**
+ * NOTE: Don't export: Obj.Any and Obj.Obj form the public API.
+ */
+interface BaseObj extends EchoSchema.HasId, Type.OfKind<EchoSchema.EntityKind.Object> {}
 
 /**
  * Object type with specific properties.
  */
-export type Obj<Props> = ObjBase & Props;
+export type Obj<Props> = BaseObj & Props;
 
 /**
  * Base type for all ECHO objects.
  */
-export interface Any extends ObjBase {}
+export interface Any extends BaseObj {}
+
+export const Any = Schema.Struct({}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/types/Any',
+    version: '0.1.0',
+  }),
+);
+
+type Props<T = any> = { id?: EchoSchema.ObjectId } & Type.Properties<T>;
 
-type MakeProps<T> = {
-  id?: EchoSchema.ObjectId;
-} & Type.Properties<T>;
+export type MakeProps<T extends Type.Obj.Any> = NoInfer<Props<Schema.Schema.Type<T>>> & {
+  [Meta]?: Partial<EchoSchema.ObjectMeta>;
+};
+
+export const Meta: unique symbol = EchoSchema.MetaId as any;
+
+// TODO(dmaretskyi): Expose Meta = EchoSchema.MetaId.
 
 /**
  * Creates new object.
+ * @param schema - Object schema.
+ * @param props - Object properties.
+ * @param meta - Object metadata (deprecated) -- pass with Obj.Meta.
+ *
+ * Meta can be passed as a symbol in `props`.
+ *
+ * Example:
+ * ```ts
+ * const obj = Obj.make(Person, { [Obj.Meta]: { keys: [...] }, name: 'John' });
+ * ```
  */
-// TODO(dmaretskyi): Move meta into props.
 export const make = <S extends Type.Obj.Any>(
   schema: S,
-  props: NoInfer<MakeProps<Schema.Schema.Type<S>>>,
+  props: MakeProps<S>,
   meta?: EchoSchema.ObjectMeta,
 ): LiveObject.Live<Schema.Schema.Type<S>> => {
   assertArgument(
     EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Object,
+    'schema',
     'Expected an object schema',
   );
 
@@ -90,8 +114,8 @@ export const instanceOf: {
 export const getSchema = EchoSchema.getSchema;
 
 // TODO(dmaretskyi): Allow returning undefined.
-export const getDXN = (obj: Any): DXN => {
-  assertArgument(!Schema.isSchema(obj), 'Object should not be a schema.');
+export const getDXN = (obj: Any | Relation.Any): DXN => {
+  assertArgument(!Schema.isSchema(obj), 'obj', 'Object should not be a schema.');
   const dxn = EchoSchema.getObjectDXN(obj);
   invariant(dxn != null, 'Invalid object.');
   return dxn;
@@ -108,7 +132,7 @@ export const getTypeDXN = EchoSchema.getType;
  * @returns The typename of the object's type.
  * @example `example.com/type/Contact`
  */
-export const getTypename = (obj: Any): string | undefined => {
+export const getTypename = (obj: Any | Relation.Any): string | undefined => {
   const schema = getSchema(obj);
   if (schema == null) {
     // Try to extract typename from DXN.
@@ -119,26 +143,61 @@ export const getTypename = (obj: Any): string | undefined => {
 };
 
 // TODO(dmaretskyi): Allow returning undefined.
-export const getMeta = (obj: Any): EchoSchema.ObjectMeta => {
+export const getMeta = (obj: Any | Relation.Any): EchoSchema.ObjectMeta => {
   const meta = EchoSchema.getMeta(obj);
   invariant(meta != null, 'Invalid object.');
   return meta;
 };
 
+/**
+ * @returns Foreign keys for the object from the specified source.
+ */
+export const getKeys: {
+  (obj: Any | Relation.Any, source: string): EchoSchema.ForeignKey[];
+  (source: string): (obj: Any | Relation.Any) => EchoSchema.ForeignKey[];
+} = dual(2, (obj: Any | Relation.Any, source?: string): EchoSchema.ForeignKey[] => {
+  const meta = EchoSchema.getMeta(obj);
+  invariant(meta != null, 'Invalid object.');
+  return meta.keys.filter((key) => key.source === source);
+});
+
+/**
+ * Delete all keys from the object for the specified source.
+ * @param obj
+ * @param source
+ */
+export const deleteKeys = (obj: Any | Relation.Any, source: string) => {
+  const meta = EchoSchema.getMeta(obj);
+  for (let i = 0; i < meta.keys.length; i++) {
+    if (meta.keys[i].source === source) {
+      meta.keys.splice(i, 1);
+      i--;
+    }
+  }
+};
+
 // TODO(dmaretskyi): Default to `false`.
-export const isDeleted = (obj: Any): boolean => {
+export const isDeleted = (obj: Any | Relation.Any): boolean => {
   const deleted = EchoSchema.isDeleted(obj);
   invariant(typeof deleted === 'boolean', 'Invalid object.');
   return deleted;
 };
 
-export const getLabel = (obj: Any): string | undefined => {
+// TODO(burdon): Rename "label"
+export const getLabel = (obj: Any | Relation.Any): string | undefined => {
   const schema = getSchema(obj);
   if (schema != null) {
     return EchoSchema.getLabel(schema, obj);
   }
 };
 
+export const setLabel = (obj: Any | Relation.Any, label: string) => {
+  const schema = getSchema(obj);
+  if (schema != null) {
+    EchoSchema.setLabel(schema, obj, label);
+  }
+};
+
 /**
  * JSON representation of an object.
  */
@@ -149,6 +208,7 @@ export type JSON = EchoSchema.ObjectJSON;
  *
  * The same algorithm is used when calling the standard `JSON.stringify(obj)` function.
  */
+// TODO(burdon): Base util type for Obj/Relation?
 export const toJSON = (obj: Any | Relation.Any): JSON => EchoSchema.objectToJSON(obj);
 
 /**
@@ -156,6 +216,139 @@ export const toJSON = (obj: Any | Relation.Any): JSON => EchoSchema.objectToJSON
  * References and schemas will be resolvable if the `refResolver` is provided.
  *
  * The function need to 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`.
  */
-export const fromJSON: (json: unknown, options?: { refResolver?: Ref.Resolver }) => Promise<Any> =
+export const fromJSON: (json: unknown, options?: { refResolver?: Ref.Resolver; dxn?: DXN }) => Promise<Any> =
   EchoSchema.objectFromJSON as any;
+
+/**
+ * Returns an immutable snapshot of an object.
+ */
+export const getSnapshot: <T extends Any>(obj: Obj<T>) => T = LiveObject.getSnapshot;
+
+export type CloneOptions = {
+  /**
+   * Retain the original object's ID.
+   * @default false
+   */
+  retainId?: boolean;
+};
+
+/**
+ * Clones an object or relation.
+ * This does not clone referenced objects, only the properties in the object.
+ * @returns A new object with the same schema and properties.
+ */
+export const clone = <T extends Any | Relation.Any>(obj: T, opts?: CloneOptions): T => {
+  const { id, ...data } = obj;
+  const schema = getSchema(obj);
+  invariant(schema != null, 'Object should have a schema');
+  const props: any = deepMapValues(data, (value, recurse) => {
+    if (EchoSchema.Ref.isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  if (opts?.retainId) {
+    props.id = id;
+  }
+  const meta = getMeta(obj);
+  props[EchoSchema.MetaId] = deepMapValues(meta, (value, recurse) => {
+    if (EchoSchema.Ref.isRef(value)) {
+      return value;
+    }
+    return recurse(value);
+  });
+  return make(schema, props);
+};
+
+export const VersionTypeId = EchoSchema.VersionTypeId;
+export type VersionType = typeof VersionTypeId;
+
+/**
+ * Represent object version.
+ * May be backed by Automerge.
+ * Objects with no history are not versioned.
+ */
+export interface Version {
+  [VersionTypeId]: {};
+
+  /**
+   * Whether the object is versioned.
+   */
+  versioned: boolean;
+
+  /**
+   * Automerge heads.
+   */
+  automergeHeads?: string[];
+}
+
+const unversioned: Version = {
+  [VersionTypeId]: {},
+  versioned: false,
+};
+
+/**
+ * Checks that `obj` is a version object.
+ */
+export const isVersion = (obj: unknown): obj is Version => {
+  return obj != null && typeof obj === 'object' && VersionTypeId in obj;
+};
+
+/**
+ * Returns the version of the object.
+ */
+export const version = (obj: Any | Relation.Any): Version => {
+  const version = (obj as any)[EchoSchema.ObjectVersionId];
+  if (version === undefined) {
+    return unversioned;
+  }
+  return version;
+};
+
+/**
+ * Checks that `version` is a valid version object.
+ */
+export const versionValid = (version: Version): boolean => {
+  assertArgument(isVersion(version), 'version', 'Invalid version object');
+  return !!version.versioned;
+};
+
+export type VersionCompareResult = 'unversioned' | 'equal' | 'different';
+
+/**
+ * Compares two versions.
+ * @param version1
+ * @param version2
+ * @returns 'unversioned' if either object is unversioned, 'equal' if the versions are equal, 'different' if the versions are different.
+ */
+export const compareVersions = (version1: Version, version2: Version): VersionCompareResult => {
+  assertArgument(isVersion(version1), 'version1', 'Invalid version object');
+  assertArgument(isVersion(version2), 'version2', 'Invalid version object');
+
+  if (!versionValid(version1) || !versionValid(version2)) {
+    return 'unversioned';
+  }
+
+  if (version1.automergeHeads?.length !== version2.automergeHeads?.length) {
+    return 'different';
+  }
+  if (version1.automergeHeads?.some((head) => !version2.automergeHeads?.includes(head))) {
+    return 'different';
+  }
+
+  return 'equal';
+};
+
+export const encodeVersion = (version: Version): string => {
+  return JSON.stringify(version);
+};
+
+export const decodeVersion = (version: string): Version => {
+  const parsed = JSON.parse(version);
+  parsed[VersionTypeId] = {};
+  return parsed;
+};

package/src/Relation.ts

@@ -2,7 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Schema } from 'effect';
+import { Schema } from 'effect';
 
 import { raise } from '@dxos/debug';
 import * as EchoSchema from '@dxos/echo-schema';
@@ -11,25 +11,35 @@ import { DXN } from '@dxos/keys';
 import { type Live, live } from '@dxos/live-object';
 import { assumeType } from '@dxos/util';
 
-import type * as Obj from './Obj';
-import type * as Type from './Type';
+import * as Obj from './Obj';
+import * as Type from './Type';
 
-// NOTE: Don't export: Relation.Relation and Relation.Any form the public API.
-interface RelationBase<Source, Target>
-  extends Type.Relation.Endpoints<Source, Target>,
-    Type.OfKind<EchoSchema.EntityKind.Relation> {
-  readonly id: EchoSchema.ObjectId;
-}
+/**
+ * NOTE: Don't export: Relation.Relation and Relation.Any form the public API.
+ */
+interface BaseRelation<Source, Target>
+  extends EchoSchema.HasId,
+    Type.Relation.Endpoints<Source, Target>,
+    Type.OfKind<EchoSchema.EntityKind.Relation> {}
 
 /**
  * Relation type with specific properties.
  */
-export type Relation<Source extends Obj.Any, Target extends Obj.Any, Props> = RelationBase<Source, Target> & Props;
+export type Relation<Source extends Obj.Any, Target extends Obj.Any, Props> = BaseRelation<Source, Target> & Props;
 
 /**
  * Base type for all ECHO relations.
  */
-export interface Any extends RelationBase<Obj.Any, Obj.Any> {}
+export interface Any extends BaseRelation<Obj.Any, Obj.Any> {}
+
+export const Any = Schema.Struct({}).pipe(
+  Type.Relation({
+    typename: 'dxos.org/types/Any',
+    version: '0.1.0',
+    source: Obj.Any,
+    target: Obj.Any,
+  }),
+);
 
 // TODO(dmaretskyi): Has to be `unique symbol`.
 export const Source: unique symbol = EchoSchema.RelationSourceId as any;
@@ -59,6 +69,7 @@ export const make = <S extends Type.Relation.Any>(
 ): Live<Schema.Schema.Type<S> & Type.OfKind<EchoSchema.EntityKind.Relation>> => {
   assertArgument(
     EchoSchema.getTypeAnnotation(schema)?.kind === EchoSchema.EntityKind.Relation,
+    'schema',
     'Expected a relation schema',
   );
 

package/src/Type.ts

@@ -3,20 +3,24 @@
 //
 
 import { type Schema } from 'effect';
-import type { Simplify } from 'effect/Schema';
+import { type Simplify } from 'effect/Schema';
 
-import type { EncodedReference } from '@dxos/echo-protocol';
+import { type EncodedReference } from '@dxos/echo-protocol';
 import * as EchoSchema from '@dxos/echo-schema';
-import type { ToMutable } from '@dxos/echo-schema';
+import { type ToMutable } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import type * as Keys from '@dxos/keys';
 
 import type * as RelationModule from './Relation';
 
+//
+// Kind
+//
+
 export const KindId: unique symbol = EchoSchema.EntityKindId as any;
 export type KindId = typeof KindId;
 
-export { EntityKind as Kind } from '@dxos/echo-schema';
+export const Kind = EchoSchema.EntityKind;
 
 /**
  * Assigns a kind to an Object or Relation instance.
@@ -27,25 +31,23 @@ export interface OfKind<Kind extends EchoSchema.EntityKind> {
   readonly [KindId]: Kind;
 }
 
-interface ObjJsonProps {
-  id: string;
-}
-
-interface RelationJsonProps {
-  id: string;
-  [EchoSchema.ATTR_RELATION_SOURCE]: string;
-  [EchoSchema.ATTR_RELATION_TARGET]: string;
-}
-
 /**
- * Returns all properties of an object or relation except for the id and kind.
+ * Base ECHO schema type.
  */
-export type Properties<T> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;
+export type Schema = EchoSchema.EchoSchema;
 
 /**
- * Base ECHO schema type.
+ * Returns all properties of an object or relation except for the id and kind.
  */
-export type Schema = EchoSchema.EchoSchema;
+export type Properties<T = any> = Omit<T, 'id' | KindId | RelationModule.Source | RelationModule.Target>;
+
+//
+// Obj
+//
+
+interface ObjJsonProps {
+  id: string;
+}
 
 /**
  * Return type of the `Obj` schema constructor.
@@ -54,13 +56,13 @@ export type Schema = EchoSchema.EchoSchema;
  * See Effect's note on interface types.
  */
 export interface obj<Self extends Schema.Schema.Any>
-  extends Schema.AnnotableClass<
+  extends EchoSchema.TypeMeta,
+    Schema.AnnotableClass<
       obj<Self>,
       OfKind<EchoSchema.EntityKind.Object> & ToMutable<Schema.Schema.Type<Self>>,
       Simplify<ObjJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
       Schema.Schema.Context<Self>
-    >,
-    EchoSchema.TypeMeta {}
+    > {}
 
 /**
  * Object schema.
@@ -72,15 +74,39 @@ export const Obj: {
 /**
  * Object schema type definitions.
  */
-export namespace Obj {
+export declare namespace Obj {
   /**
    * Type that represents an arbitrary schema type of an object.
    * NOTE: This is not an instance type.
    */
   // TODO(dmaretskyi): If schema was covariant, we could specify props in here, like `id: ObjectId`.
+  // TODO(burdon): This erases the ECHO type info (e.g., id, typename).
   export type Any = Schema.Schema.AnyNoContext;
 }
 
+//
+// Expando
+//
+
+// TODO(burdon): We're using Expando in many places as a base type.
+export interface Expando extends OfKind<EchoSchema.EntityKind.Object> {
+  [key: string]: any;
+}
+
+type ExpandoEncoded = Simplify<ObjJsonProps & { [key: string]: any }>;
+
+export const Expando: Schema.Schema<Expando, ExpandoEncoded, never> = EchoSchema.Expando as any;
+
+//
+// Relation
+//
+
+interface RelationJsonProps {
+  id: string;
+  [EchoSchema.ATTR_RELATION_SOURCE]: string;
+  [EchoSchema.ATTR_RELATION_TARGET]: string;
+}
+
 /**
  * Return type of the `Relation` schema constructor.
  *
@@ -91,15 +117,15 @@ export interface relation<
   Self extends Schema.Schema.Any,
   SourceSchema extends Schema.Schema.Any,
   TargetSchema extends Schema.Schema.Any,
-> extends Schema.AnnotableClass<
+> extends EchoSchema.TypeMeta,
+    Schema.AnnotableClass<
       relation<Self, SourceSchema, TargetSchema>,
       OfKind<EchoSchema.EntityKind.Relation> &
         Relation.Endpoints<Schema.Schema.Type<SourceSchema>, Schema.Schema.Type<TargetSchema>> &
         ToMutable<Schema.Schema.Type<Self>>,
       Simplify<RelationJsonProps & ToMutable<Schema.Schema.Encoded<Self>>>,
       Schema.Schema.Context<Self>
-    >,
-    EchoSchema.TypeMeta {}
+    > {}
 
 /**
  * Relation schema.
@@ -123,14 +149,14 @@ export namespace Relation {
   export type Any = Schema.Schema.AnyNoContext;
 
   /**
-   * Get relation target type.
+   * Get relation source type.
    */
-  export type Target<A> = A extends Relation.Endpoints<infer _S, infer T> ? T : never;
+  export type Source<A> = A extends Relation.Endpoints<infer S, infer _T> ? S : never;
 
   /**
-   * Get relation source type.
+   * Get relation target type.
    */
-  export type Source<A> = A extends Relation.Endpoints<infer S, infer _T> ? S : never;
+  export type Target<A> = A extends Relation.Endpoints<infer _S, infer T> ? T : never;
 
   export type Endpoints<Source, Target> = {
     [RelationModule.Source]: Source;
@@ -138,6 +164,10 @@ export namespace Relation {
   };
 }
 
+//
+// Ref
+//
+
 /**
  * Return type of the `Ref` schema constructor.
  *
@@ -193,6 +223,11 @@ export const getVersion = (schema: Obj.Any | Relation.Any): string => {
   return version;
 };
 
+/**
+ * @returns True if the schema is mutable.
+ */
+export const isMutable = EchoSchema.isMutable;
+
 /**
  * ECHO type metadata.
  */
@@ -205,27 +240,7 @@ export const getMeta = (schema: Obj.Any | Relation.Any): Meta | undefined => {
   return EchoSchema.getTypeAnnotation(schema);
 };
 
-/**
- * @returns True if the schema is mutable.
- */
-export const isMutable = EchoSchema.isMutable;
-
+// TODO(dmaretskyi): Remove re-exports.
 export { SpaceId, ObjectId, DXN } from '@dxos/keys';
 
-export interface Expando extends OfKind<EchoSchema.EntityKind.Object> {
-  [key: string]: any;
-}
-
-export const Expando: Schema.Schema<
-  Expando,
-  Simplify<ObjJsonProps & { [key: string]: any }>,
-  never
-> = EchoSchema.Expando as any;
-
-export {
-  // TODO(burdon): Standardize.
-  Format,
-  JsonSchemaType as JsonSchema,
-  toEffectSchema,
-  toJsonSchema,
-} from '@dxos/echo-schema';
+export { Format, JsonSchemaType as JsonSchema, toEffectSchema, toJsonSchema } from '@dxos/echo-schema';

package/src/errors.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { BaseError, type BaseErrorOptions } from '@dxos/errors';
+import { type DXN } from '@dxos/keys';
+
+export class SchemaNotFoundError extends BaseError.extend('SCHEMA_NOT_FOUND', 'Schema not found') {
+  constructor(schema: string, options?: BaseErrorOptions) {
+    super({ context: { schema }, ...options });
+  }
+}
+
+export class ObjectNotFoundError extends BaseError.extend('OBJECT_NOT_FOUND', 'Object not found') {
+  constructor(dxn: DXN, options?: BaseErrorOptions) {
+    super({ context: { dxn }, ...options });
+  }
+}